---
Function {
    argument: None,
    arguments: FunctionArguments {
        arguments: [
            FunctionArgument {
                identifier: "nixosTests",
                default: None,
            },
            FunctionArgument {
                identifier: "wrapGAppsHook",
                default: None,
            },
            FunctionArgument {
                identifier: "pcre2",
                default: None,
            },
            FunctionArgument {
                identifier: "ncurses",
                default: None,
            },
            FunctionArgument {
                identifier: "gtk3",
                default: None,
            },
            FunctionArgument {
                identifier: "vte",
                default: None,
            },
            FunctionArgument {
                identifier: "pkg-config",
                default: None,
            },
            FunctionArgument {
                identifier: "fetchpatch",
                default: None,
            },
            FunctionArgument {
                identifier: "fetchFromGitHub",
                default: None,
            },
            FunctionArgument {
                identifier: "stdenv",
                default: None,
            },
            FunctionArgument {
                identifier: "lib",
                default: None,
            },
        ],
        ellipsis: false,
    },
    definition: LetIn {
        bindings: [
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "vte-ng",
                            position: (9, 3),
                        },
                    ],
                },
                FunctionApplication {
                    function: PropertyAccess {
                        expression: Variable {
                            identifier: "vte",
                            position: (9, 13),
                        },
                        attribute_path: AttributePath {
                            attributes: [
                                Raw {
                                    content: "overrideAttrs",
                                    position: (9, 17),
                                },
                            ],
                        },
                        default: None,
                    },
                    arguments: [
                        Function {
                            argument: Some(
                                "attrs",
                            ),
                            arguments: FunctionArguments {
                                arguments: [],
                                ellipsis: false,
                            },
                            definition: Map {
                                bindings: [
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "patches",
                                                    position: (10, 5),
                                                },
                                            ],
                                        },
                                        BinaryOperation {
                                            operator: Concatenation,
                                            operands: [
                                                PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "attrs",
                                                        position: (10, 15),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "patches",
                                                                position: (10, 21),
                                                            },
                                                        ],
                                                    },
                                                    default: Some(
                                                        List {
                                                            elements: [],
                                                        },
                                                    ),
                                                },
                                                List {
                                                    elements: [
                                                        FunctionApplication {
                                                            function: Variable {
                                                                identifier: "fetchpatch",
                                                                position: (11, 8),
                                                            },
                                                            arguments: [
                                                                Map {
                                                                    bindings: [
                                                                        KeyValue(
                                                                            AttributePath {
                                                                                attributes: [
                                                                                    Raw {
                                                                                        content: "name",
                                                                                        position: (12, 9),
                                                                                    },
                                                                                ],
                                                                            },
                                                                            String {
                                                                                parts: [
                                                                                    Raw {
                                                                                        content: "0001-expose-functions-for-pausing-unpausing-output.patch",
                                                                                        position: (12, 17),
                                                                                    },
                                                                                ],
                                                                            },
                                                                        ),
                                                                        KeyValue(
                                                                            AttributePath {
                                                                                attributes: [
                                                                                    Raw {
                                                                                        content: "url",
                                                                                        position: (13, 9),
                                                                                    },
                                                                                ],
                                                                            },
                                                                            String {
                                                                                parts: [
                                                                                    Raw {
                                                                                        content: "https://github.com/thestinger/vte-ng/commit/342e26574f50dcd40bbeaad9e839c2a6144d0c1c.patch",
                                                                                        position: (13, 16),
                                                                                    },
                                                                                ],
                                                                            },
                                                                        ),
                                                                        KeyValue(
                                                                            AttributePath {
                                                                                attributes: [
                                                                                    Raw {
                                                                                        content: "sha256",
                                                                                        position: (14, 9),
                                                                                    },
                                                                                ],
                                                                            },
                                                                            String {
                                                                                parts: [
                                                                                    Raw {
                                                                                        content: "1b0k9ys545q85vfki417p21kis9f36yd0hyp12phayynss6fn715",
                                                                                        position: (14, 19),
                                                                                    },
                                                                                ],
                                                                            },
                                                                        ),
                                                                    ],
                                                                    recursive: false,
                                                                },
                                                            ],
                                                        },
                                                        Path {
                                                            parts: [
                                                                Raw {
                                                                    content: "./vte-ng-modified-patches/vte-0002-expose-function-for-setting-cursor-position.patch",
                                                                    position: (17, 7),
                                                                },
                                                            ],
                                                        },
                                                        Path {
                                                            parts: [
                                                                Raw {
                                                                    content: "./vte-ng-modified-patches/vte-0003-add-function-for-setting-the-text-selections.patch",
                                                                    position: (19, 7),
                                                                },
                                                            ],
                                                        },
                                                        FunctionApplication {
                                                            function: Variable {
                                                                identifier: "fetchpatch",
                                                                position: (20, 8),
                                                            },
                                                            arguments: [
                                                                Map {
                                                                    bindings: [
                                                                        KeyValue(
                                                                            AttributePath {
                                                                                attributes: [
                                                                                    Raw {
                                                                                        content: "name",
                                                                                        position: (21, 9),
                                                                                    },
                                                                                ],
                                                                            },
                                                                            String {
                                                                                parts: [
                                                                                    Raw {
                                                                                        content: "0004-add-functions-to-get-set-block-selection-mode.patch",
                                                                                        position: (21, 17),
                                                                                    },
                                                                                ],
                                                                            },
                                                                        ),
                                                                        KeyValue(
                                                                            AttributePath {
                                                                                attributes: [
                                                                                    Raw {
                                                                                        content: "url",
                                                                                        position: (22, 9),
                                                                                    },
                                                                                ],
                                                                            },
                                                                            String {
                                                                                parts: [
                                                                                    Raw {
                                                                                        content: "https://github.com/thestinger/vte-ng/commit/08748fd9cb82bd191e5c476b1682ca71f7732572.patch",
                                                                                        position: (22, 16),
                                                                                    },
                                                                                ],
                                                                            },
                                                                        ),
                                                                        KeyValue(
                                                                            AttributePath {
                                                                                attributes: [
                                                                                    Raw {
                                                                                        content: "sha256",
                                                                                        position: (23, 9),
                                                                                    },
                                                                                ],
                                                                            },
                                                                            String {
                                                                                parts: [
                                                                                    Raw {
                                                                                        content: "1cnhd8f7ywdgcyd6xmcd2nn39jjxzkxp4d0zsj2k7m5v74nhcs1g",
                                                                                        position: (23, 19),
                                                                                    },
                                                                                ],
                                                                            },
                                                                        ),
                                                                    ],
                                                                    recursive: false,
                                                                },
                                                            ],
                                                        },
                                                        Path {
                                                            parts: [
                                                                Raw {
                                                                    content: "./vte-ng-modified-patches/vte-0005-expose-function-for-getting-the-selected-text.patch",
                                                                    position: (26, 7),
                                                                },
                                                            ],
                                                        },
                                                    ],
                                                },
                                            ],
                                        },
                                    ),
                                ],
                                recursive: false,
                            },
                        },
                    ],
                },
            ),
        ],
        target: FunctionApplication {
            function: PropertyAccess {
                expression: Variable {
                    identifier: "stdenv",
                    position: (30, 4),
                },
                attribute_path: AttributePath {
                    attributes: [
                        Raw {
                            content: "mkDerivation",
                            position: (30, 11),
                        },
                    ],
                },
                default: None,
            },
            arguments: [
                Map {
                    bindings: [
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "pname",
                                        position: (31, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "termite",
                                        position: (31, 12),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "version",
                                        position: (32, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "15",
                                        position: (32, 14),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "src",
                                        position: (34, 3),
                                    },
                                ],
                            },
                            FunctionApplication {
                                function: Variable {
                                    identifier: "fetchFromGitHub",
                                    position: (34, 9),
                                },
                                arguments: [
                                    Map {
                                        bindings: [
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "owner",
                                                            position: (35, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "thestinger",
                                                            position: (35, 14),
                                                        },
                                                    ],
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "repo",
                                                            position: (36, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "termite",
                                                            position: (36, 13),
                                                        },
                                                    ],
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "rev",
                                                            position: (37, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "v",
                                                            position: (37, 12),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "version",
                                                                position: (37, 15),
                                                            },
                                                        },
                                                    ],
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "sha256",
                                                            position: (38, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "0hp1x6lj098m3jgna274wv5dv60lnzg22297di68g4hw9djjyd2k",
                                                            position: (38, 15),
                                                        },
                                                    ],
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "fetchSubmodules",
                                                            position: (39, 5),
                                                        },
                                                    ],
                                                },
                                                Variable {
                                                    identifier: "true",
                                                    position: (39, 23),
                                                },
                                            ),
                                        ],
                                        recursive: false,
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "patches",
                                        position: (43, 3),
                                    },
                                ],
                            },
                            BinaryOperation {
                                operator: Concatenation,
                                operands: [
                                    List {
                                        elements: [
                                            Path {
                                                parts: [
                                                    Raw {
                                                        content: "./url_regexp_trailing.patch",
                                                        position: (43, 15),
                                                    },
                                                ],
                                            },
                                            Path {
                                                parts: [
                                                    Raw {
                                                        content: "./add_errno_header.patch",
                                                        position: (43, 43),
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: Variable {
                                                    identifier: "fetchpatch",
                                                    position: (46, 6),
                                                },
                                                arguments: [
                                                    Map {
                                                        bindings: [
                                                            KeyValue(
                                                                AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "url",
                                                                            position: (47, 7),
                                                                        },
                                                                    ],
                                                                },
                                                                String {
                                                                    parts: [
                                                                        Raw {
                                                                            content: "https://github.com/thestinger/termite/commit/7e9a93b421b9596f8980645a46ac2ad5468dac06.patch",
                                                                            position: (47, 14),
                                                                        },
                                                                    ],
                                                                },
                                                            ),
                                                            KeyValue(
                                                                AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "sha256",
                                                                            position: (48, 7),
                                                                        },
                                                                    ],
                                                                },
                                                                String {
                                                                    parts: [
                                                                        Raw {
                                                                            content: "0vph2m5919f7w1xnc8i6z0j44clsm1chxkfg7l71nahxyfw5yh4j",
                                                                            position: (48, 17),
                                                                        },
                                                                    ],
                                                                },
                                                            ),
                                                        ],
                                                        recursive: false,
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                    FunctionApplication {
                                        function: PropertyAccess {
                                            expression: Variable {
                                                identifier: "lib",
                                                position: (50, 8),
                                            },
                                            attribute_path: AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "optional",
                                                        position: (50, 12),
                                                    },
                                                ],
                                            },
                                            default: None,
                                        },
                                        arguments: [
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "stdenv",
                                                    position: (50, 21),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "isDarwin",
                                                            position: (50, 28),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                            Path {
                                                parts: [
                                                    Raw {
                                                        content: "./remove_ldflags_macos.patch",
                                                        position: (50, 37),
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "makeFlags",
                                        position: (52, 3),
                                    },
                                ],
                            },
                            List {
                                elements: [
                                    String {
                                        parts: [
                                            Raw {
                                                content: "VERSION=v",
                                                position: (52, 18),
                                            },
                                            Expression {
                                                expression: Variable {
                                                    identifier: "version",
                                                    position: (52, 29),
                                                },
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "PREFIX=",
                                                position: (52, 40),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "DESTDIR=$(out)",
                                                position: (52, 50),
                                            },
                                        ],
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "buildInputs",
                                        position: (54, 3),
                                    },
                                ],
                            },
                            List {
                                elements: [
                                    Variable {
                                        identifier: "vte-ng",
                                        position: (54, 19),
                                    },
                                    Variable {
                                        identifier: "gtk3",
                                        position: (54, 26),
                                    },
                                    Variable {
                                        identifier: "ncurses",
                                        position: (54, 31),
                                    },
                                    Variable {
                                        identifier: "pcre2",
                                        position: (54, 39),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "nativeBuildInputs",
                                        position: (56, 3),
                                    },
                                ],
                            },
                            List {
                                elements: [
                                    Variable {
                                        identifier: "wrapGAppsHook",
                                        position: (56, 25),
                                    },
                                    Variable {
                                        identifier: "pkg-config",
                                        position: (56, 39),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "outputs",
                                        position: (58, 3),
                                    },
                                ],
                            },
                            List {
                                elements: [
                                    String {
                                        parts: [
                                            Raw {
                                                content: "out",
                                                position: (58, 16),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "terminfo",
                                                position: (58, 22),
                                            },
                                        ],
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "passthru",
                                        position: (60, 3),
                                    },
                                ],
                            },
                            Map {
                                bindings: [
                                    Inherit(
                                        None,
                                        [
                                            Raw {
                                                content: "vte-ng",
                                                position: (61, 13),
                                            },
                                        ],
                                    ),
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "tests",
                                                    position: (62, 5),
                                                },
                                            ],
                                        },
                                        PropertyAccess {
                                            expression: Variable {
                                                identifier: "nixosTests",
                                                position: (62, 13),
                                            },
                                            attribute_path: AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "terminal-emulators",
                                                        position: (62, 24),
                                                    },
                                                    Raw {
                                                        content: "termite",
                                                        position: (62, 43),
                                                    },
                                                ],
                                            },
                                            default: None,
                                        },
                                    ),
                                ],
                                recursive: false,
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "postInstall",
                                        position: (65, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "mkdir -p $terminfo/share\nmv $out/share/terminfo $terminfo/share/terminfo\n\nmkdir -p $out/nix-support\necho \"$terminfo\" >> $out/nix-support/propagated-user-env-packages\n",
                                        position: (66, 1),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "meta",
                                        position: (73, 3),
                                    },
                                ],
                            },
                            With {
                                expression: Variable {
                                    identifier: "lib",
                                    position: (73, 15),
                                },
                                target: Map {
                                    bindings: [
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "description",
                                                        position: (74, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "A simple VTE-based terminal",
                                                        position: (74, 20),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "license",
                                                        position: (75, 5),
                                                    },
                                                ],
                                            },
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "licenses",
                                                    position: (75, 15),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "lgpl2Plus",
                                                            position: (75, 24),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "homepage",
                                                        position: (76, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "https://github.com/thestinger/termite/",
                                                        position: (76, 17),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "maintainers",
                                                        position: (77, 5),
                                                    },
                                                ],
                                            },
                                            With {
                                                expression: Variable {
                                                    identifier: "maintainers",
                                                    position: (77, 24),
                                                },
                                                target: List {
                                                    elements: [
                                                        Variable {
                                                            identifier: "koral",
                                                            position: (77, 39),
                                                        },
                                                    ],
                                                },
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "platforms",
                                                        position: (78, 5),
                                                    },
                                                ],
                                            },
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "platforms",
                                                    position: (78, 17),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "all",
                                                            position: (78, 27),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                        ),
                                    ],
                                    recursive: false,
                                },
                            },
                        ),
                    ],
                    recursive: true,
                },
            ],
        },
    },
}