---
Function {
    argument: None,
    arguments: FunctionArguments {
        arguments: [
            FunctionArgument {
                identifier: "libpulseaudio",
                default: None,
            },
            FunctionArgument {
                identifier: "pulseSupport",
                default: Some(
                    PropertyAccess {
                        expression: Variable {
                            identifier: "stdenv",
                            position: (15, 18),
                        },
                        attribute_path: AttributePath {
                            attributes: [
                                Raw {
                                    content: "isLinux",
                                    position: (15, 25),
                                },
                            ],
                        },
                        default: None,
                    },
                ),
            },
            FunctionArgument {
                identifier: "commandLineArgs",
                default: Some(
                    String {
                        parts: [],
                    },
                ),
            },
            FunctionArgument {
                identifier: "vivaldi-widevine",
                default: Some(
                    Variable {
                        identifier: "null",
                        position: (13, 46),
                    },
                ),
            },
            FunctionArgument {
                identifier: "enableWidevine",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (13, 20),
                    },
                ),
            },
            FunctionArgument {
                identifier: "vivaldi-ffmpeg-codecs",
                default: Some(
                    Variable {
                        identifier: "null",
                        position: (12, 54),
                    },
                ),
            },
            FunctionArgument {
                identifier: "proprietaryCodecs",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (12, 23),
                    },
                ),
            },
            FunctionArgument {
                identifier: "isSnapshot",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (11, 16),
                    },
                ),
            },
            FunctionArgument {
                identifier: "makeWrapper",
                default: None,
            },
            FunctionArgument {
                identifier: "patchelf",
                default: None,
            },
            FunctionArgument {
                identifier: "nspr",
                default: None,
            },
            FunctionArgument {
                identifier: "nss",
                default: None,
            },
            FunctionArgument {
                identifier: "mesa",
                default: None,
            },
            FunctionArgument {
                identifier: "libdrm",
                default: None,
            },
            FunctionArgument {
                identifier: "at-spi2-core",
                default: None,
            },
            FunctionArgument {
                identifier: "at-spi2-atk",
                default: None,
            },
            FunctionArgument {
                identifier: "atk",
                default: None,
            },
            FunctionArgument {
                identifier: "cairo",
                default: None,
            },
            FunctionArgument {
                identifier: "gdk-pixbuf",
                default: None,
            },
            FunctionArgument {
                identifier: "pango",
                default: None,
            },
            FunctionArgument {
                identifier: "gtk3",
                default: None,
            },
            FunctionArgument {
                identifier: "glib",
                default: None,
            },
            FunctionArgument {
                identifier: "libxml2",
                default: None,
            },
            FunctionArgument {
                identifier: "libuuid",
                default: None,
            },
            FunctionArgument {
                identifier: "expat",
                default: None,
            },
            FunctionArgument {
                identifier: "libxcb",
                default: None,
            },
            FunctionArgument {
                identifier: "libXrender",
                default: None,
            },
            FunctionArgument {
                identifier: "libXft",
                default: None,
            },
            FunctionArgument {
                identifier: "fontconfig",
                default: None,
            },
            FunctionArgument {
                identifier: "freetype",
                default: None,
            },
            FunctionArgument {
                identifier: "libva",
                default: None,
            },
            FunctionArgument {
                identifier: "systemd",
                default: None,
            },
            FunctionArgument {
                identifier: "ffmpeg",
                default: None,
            },
            FunctionArgument {
                identifier: "libexif",
                default: None,
            },
            FunctionArgument {
                identifier: "cups",
                default: None,
            },
            FunctionArgument {
                identifier: "dbus",
                default: None,
            },
            FunctionArgument {
                identifier: "alsa-lib",
                default: None,
            },
            FunctionArgument {
                identifier: "libXrandr",
                default: None,
            },
            FunctionArgument {
                identifier: "libXtst",
                default: None,
            },
            FunctionArgument {
                identifier: "libXdamage",
                default: None,
            },
            FunctionArgument {
                identifier: "libXcomposite",
                default: None,
            },
            FunctionArgument {
                identifier: "libXScrnSaver",
                default: None,
            },
            FunctionArgument {
                identifier: "libXcursor",
                default: None,
            },
            FunctionArgument {
                identifier: "libXi",
                default: None,
            },
            FunctionArgument {
                identifier: "libXt",
                default: None,
            },
            FunctionArgument {
                identifier: "libXfixes",
                default: None,
            },
            FunctionArgument {
                identifier: "libxshmfence",
                default: None,
            },
            FunctionArgument {
                identifier: "libxkbcommon",
                default: None,
            },
            FunctionArgument {
                identifier: "libICE",
                default: None,
            },
            FunctionArgument {
                identifier: "libSM",
                default: None,
            },
            FunctionArgument {
                identifier: "libXext",
                default: None,
            },
            FunctionArgument {
                identifier: "libX11",
                default: None,
            },
            FunctionArgument {
                identifier: "zlib",
                default: None,
            },
            FunctionArgument {
                identifier: "fetchurl",
                default: None,
            },
            FunctionArgument {
                identifier: "stdenv",
                default: None,
            },
            FunctionArgument {
                identifier: "lib",
                default: None,
            },
        ],
        ellipsis: false,
    },
    definition: LetIn {
        bindings: [
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "branch",
                            position: (19, 3),
                        },
                    ],
                },
                IfThenElse {
                    predicate: Variable {
                        identifier: "isSnapshot",
                        position: (19, 15),
                    },
                    then: String {
                        parts: [
                            Raw {
                                content: "snapshot",
                                position: (19, 32),
                            },
                        ],
                    },
                    else_: String {
                        parts: [
                            Raw {
                                content: "stable",
                                position: (19, 48),
                            },
                        ],
                    },
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "vivaldiName",
                            position: (20, 3),
                        },
                    ],
                },
                IfThenElse {
                    predicate: Variable {
                        identifier: "isSnapshot",
                        position: (20, 20),
                    },
                    then: String {
                        parts: [
                            Raw {
                                content: "vivaldi-snapshot",
                                position: (20, 37),
                            },
                        ],
                    },
                    else_: String {
                        parts: [
                            Raw {
                                content: "vivaldi",
                                position: (20, 61),
                            },
                        ],
                    },
                },
            ),
        ],
        target: FunctionApplication {
            function: PropertyAccess {
                expression: Variable {
                    identifier: "stdenv",
                    position: (21, 4),
                },
                attribute_path: AttributePath {
                    attributes: [
                        Raw {
                            content: "mkDerivation",
                            position: (21, 11),
                        },
                    ],
                },
                default: None,
            },
            arguments: [
                Map {
                    bindings: [
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "pname",
                                        position: (22, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "vivaldi",
                                        position: (22, 12),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "version",
                                        position: (23, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "5.1.2567.73-1",
                                        position: (23, 14),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "src",
                                        position: (25, 3),
                                    },
                                ],
                            },
                            FunctionApplication {
                                function: Variable {
                                    identifier: "fetchurl",
                                    position: (25, 9),
                                },
                                arguments: [
                                    Map {
                                        bindings: [
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "url",
                                                            position: (26, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "https://downloads.vivaldi.com/",
                                                            position: (26, 12),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "branch",
                                                                position: (26, 44),
                                                            },
                                                        },
                                                        Raw {
                                                            content: "/vivaldi-",
                                                            position: (26, 51),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "branch",
                                                                position: (26, 62),
                                                            },
                                                        },
                                                        Raw {
                                                            content: "_",
                                                            position: (26, 69),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "version",
                                                                position: (26, 72),
                                                            },
                                                        },
                                                        Raw {
                                                            content: "_amd64.deb",
                                                            position: (26, 80),
                                                        },
                                                    ],
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "sha256",
                                                            position: (27, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "04jzhipn4ip7x3zdwmfnp6w0qc2y1qdfy5w3qyy0r114jz9s9i7g",
                                                            position: (27, 15),
                                                        },
                                                    ],
                                                },
                                            ),
                                        ],
                                        recursive: false,
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "unpackPhase",
                                        position: (30, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "ar vx $src\ntar -xvf data.tar.xz\n",
                                        position: (31, 1),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "nativeBuildInputs",
                                        position: (35, 3),
                                    },
                                ],
                            },
                            List {
                                elements: [
                                    Variable {
                                        identifier: "patchelf",
                                        position: (35, 25),
                                    },
                                    Variable {
                                        identifier: "makeWrapper",
                                        position: (35, 34),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "buildInputs",
                                        position: (37, 3),
                                    },
                                ],
                            },
                            BinaryOperation {
                                operator: Concatenation,
                                operands: [
                                    List {
                                        elements: [
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "stdenv",
                                                    position: (38, 5),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "cc",
                                                            position: (38, 12),
                                                        },
                                                        Raw {
                                                            content: "cc",
                                                            position: (38, 15),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "stdenv",
                                                    position: (38, 18),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "cc",
                                                            position: (38, 25),
                                                        },
                                                        Raw {
                                                            content: "libc",
                                                            position: (38, 28),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                            Variable {
                                                identifier: "zlib",
                                                position: (38, 33),
                                            },
                                            Variable {
                                                identifier: "libX11",
                                                position: (38, 38),
                                            },
                                            Variable {
                                                identifier: "libXt",
                                                position: (38, 45),
                                            },
                                            Variable {
                                                identifier: "libXext",
                                                position: (38, 51),
                                            },
                                            Variable {
                                                identifier: "libSM",
                                                position: (38, 59),
                                            },
                                            Variable {
                                                identifier: "libICE",
                                                position: (38, 65),
                                            },
                                            Variable {
                                                identifier: "libxcb",
                                                position: (38, 72),
                                            },
                                            Variable {
                                                identifier: "libxkbcommon",
                                                position: (38, 79),
                                            },
                                            Variable {
                                                identifier: "libxshmfence",
                                                position: (38, 92),
                                            },
                                            Variable {
                                                identifier: "libXi",
                                                position: (39, 5),
                                            },
                                            Variable {
                                                identifier: "libXft",
                                                position: (39, 11),
                                            },
                                            Variable {
                                                identifier: "libXcursor",
                                                position: (39, 18),
                                            },
                                            Variable {
                                                identifier: "libXfixes",
                                                position: (39, 29),
                                            },
                                            Variable {
                                                identifier: "libXScrnSaver",
                                                position: (39, 39),
                                            },
                                            Variable {
                                                identifier: "libXcomposite",
                                                position: (39, 53),
                                            },
                                            Variable {
                                                identifier: "libXdamage",
                                                position: (39, 67),
                                            },
                                            Variable {
                                                identifier: "libXtst",
                                                position: (39, 78),
                                            },
                                            Variable {
                                                identifier: "libXrandr",
                                                position: (39, 86),
                                            },
                                            Variable {
                                                identifier: "atk",
                                                position: (40, 5),
                                            },
                                            Variable {
                                                identifier: "at-spi2-atk",
                                                position: (40, 9),
                                            },
                                            Variable {
                                                identifier: "at-spi2-core",
                                                position: (40, 21),
                                            },
                                            Variable {
                                                identifier: "alsa-lib",
                                                position: (40, 34),
                                            },
                                            Variable {
                                                identifier: "dbus",
                                                position: (40, 43),
                                            },
                                            Variable {
                                                identifier: "cups",
                                                position: (40, 48),
                                            },
                                            Variable {
                                                identifier: "gtk3",
                                                position: (40, 53),
                                            },
                                            Variable {
                                                identifier: "gdk-pixbuf",
                                                position: (40, 58),
                                            },
                                            Variable {
                                                identifier: "libexif",
                                                position: (40, 69),
                                            },
                                            Variable {
                                                identifier: "ffmpeg",
                                                position: (40, 77),
                                            },
                                            Variable {
                                                identifier: "systemd",
                                                position: (40, 84),
                                            },
                                            Variable {
                                                identifier: "libva",
                                                position: (40, 92),
                                            },
                                            Variable {
                                                identifier: "freetype",
                                                position: (41, 5),
                                            },
                                            Variable {
                                                identifier: "fontconfig",
                                                position: (41, 14),
                                            },
                                            Variable {
                                                identifier: "libXrender",
                                                position: (41, 25),
                                            },
                                            Variable {
                                                identifier: "libuuid",
                                                position: (41, 36),
                                            },
                                            Variable {
                                                identifier: "expat",
                                                position: (41, 44),
                                            },
                                            Variable {
                                                identifier: "glib",
                                                position: (41, 50),
                                            },
                                            Variable {
                                                identifier: "nss",
                                                position: (41, 55),
                                            },
                                            Variable {
                                                identifier: "nspr",
                                                position: (41, 59),
                                            },
                                            Variable {
                                                identifier: "libxml2",
                                                position: (42, 5),
                                            },
                                            Variable {
                                                identifier: "pango",
                                                position: (42, 13),
                                            },
                                            Variable {
                                                identifier: "cairo",
                                                position: (42, 19),
                                            },
                                            Variable {
                                                identifier: "libdrm",
                                                position: (43, 5),
                                            },
                                            Variable {
                                                identifier: "mesa",
                                                position: (43, 12),
                                            },
                                        ],
                                    },
                                    BinaryOperation {
                                        operator: Concatenation,
                                        operands: [
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (44, 8),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optional",
                                                                position: (44, 12),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "proprietaryCodecs",
                                                        position: (44, 21),
                                                    },
                                                    Variable {
                                                        identifier: "vivaldi-ffmpeg-codecs",
                                                        position: (44, 39),
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (45, 8),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optional",
                                                                position: (45, 12),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "pulseSupport",
                                                        position: (45, 21),
                                                    },
                                                    Variable {
                                                        identifier: "libpulseaudio",
                                                        position: (45, 34),
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "libPath",
                                        position: (47, 3),
                                    },
                                ],
                            },
                            BinaryOperation {
                                operator: Addition,
                                operands: [
                                    BinaryOperation {
                                        operator: Addition,
                                        operands: [
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (47, 13),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "makeLibraryPath",
                                                                position: (47, 17),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "buildInputs",
                                                        position: (47, 33),
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (48, 7),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optionalString",
                                                                position: (48, 11),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    PropertyAccess {
                                                        expression: Variable {
                                                            identifier: "stdenv",
                                                            position: (48, 27),
                                                        },
                                                        attribute_path: AttributePath {
                                                            attributes: [
                                                                Raw {
                                                                    content: "is64bit",
                                                                    position: (48, 34),
                                                                },
                                                            ],
                                                        },
                                                        default: None,
                                                    },
                                                    BinaryOperation {
                                                        operator: Addition,
                                                        operands: [
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: ":",
                                                                        position: (49, 9),
                                                                    },
                                                                ],
                                                            },
                                                            FunctionApplication {
                                                                function: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "lib",
                                                                        position: (49, 14),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "makeSearchPathOutput",
                                                                                position: (49, 18),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                                arguments: [
                                                                    String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "lib",
                                                                                position: (49, 40),
                                                                            },
                                                                        ],
                                                                    },
                                                                    String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "lib64",
                                                                                position: (49, 46),
                                                                            },
                                                                        ],
                                                                    },
                                                                    Variable {
                                                                        identifier: "buildInputs",
                                                                        position: (49, 53),
                                                                    },
                                                                ],
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: ":$out/opt/",
                                                position: (50, 8),
                                            },
                                            Expression {
                                                expression: Variable {
                                                    identifier: "vivaldiName",
                                                    position: (50, 20),
                                                },
                                            },
                                            Raw {
                                                content: "/lib",
                                                position: (50, 32),
                                            },
                                        ],
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "buildPhase",
                                        position: (52, 3),
                                    },
                                ],
                            },
                            BinaryOperation {
                                operator: Addition,
                                operands: [
                                    BinaryOperation {
                                        operator: Addition,
                                        operands: [
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "runHook preBuild\necho \"Patching Vivaldi binaries\"\nfor f in chrome_crashpad_handler vivaldi-bin vivaldi-sandbox ; do\n  patchelf \\\n    --set-interpreter \"$(cat $NIX_CC/nix-support/dynamic-linker)\" \\\n    --set-rpath \"",
                                                        position: (53, 1),
                                                    },
                                                    Expression {
                                                        expression: Variable {
                                                            identifier: "libPath",
                                                            position: (58, 24),
                                                        },
                                                    },
                                                    Raw {
                                                        content: "\" \\\n    opt/",
                                                        position: (58, 32),
                                                    },
                                                    Expression {
                                                        expression: Variable {
                                                            identifier: "vivaldiName",
                                                            position: (59, 15),
                                                        },
                                                    },
                                                    Raw {
                                                        content: "/$f\ndone\n",
                                                        position: (59, 27),
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (61, 8),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optionalString",
                                                                position: (61, 12),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "proprietaryCodecs",
                                                        position: (61, 27),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "ln -s ",
                                                                position: (62, 1),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "vivaldi-ffmpeg-codecs",
                                                                    position: (62, 13),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/lib/libffmpeg.so opt/",
                                                                position: (62, 35),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "vivaldiName",
                                                                    position: (62, 59),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/libffmpeg.so.",
                                                                position: (62, 71),
                                                            },
                                                            Raw {
                                                                content: "$",
                                                                position: (62, 85),
                                                            },
                                                            Raw {
                                                                content: "{version%\\.*\\.*}\n",
                                                                position: (62, 88),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "echo \"Finished patching Vivaldi binaries\"\nrunHook postBuild\n",
                                                position: (64, 1),
                                            },
                                        ],
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "dontPatchELF",
                                        position: (68, 3),
                                    },
                                ],
                            },
                            Variable {
                                identifier: "true",
                                position: (68, 18),
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "dontStrip",
                                        position: (69, 3),
                                    },
                                ],
                            },
                            Variable {
                                identifier: "true",
                                position: (69, 18),
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "installPhase",
                                        position: (71, 3),
                                    },
                                ],
                            },
                            BinaryOperation {
                                operator: Addition,
                                operands: [
                                    BinaryOperation {
                                        operator: Addition,
                                        operands: [
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "runHook preInstall\nmkdir -p \"$out\"\ncp -r opt \"$out\"\nmkdir \"$out/bin\"\nln -s \"$out/opt/",
                                                        position: (72, 1),
                                                    },
                                                    Expression {
                                                        expression: Variable {
                                                            identifier: "vivaldiName",
                                                            position: (76, 23),
                                                        },
                                                    },
                                                    Raw {
                                                        content: "/",
                                                        position: (76, 35),
                                                    },
                                                    Expression {
                                                        expression: Variable {
                                                            identifier: "vivaldiName",
                                                            position: (76, 38),
                                                        },
                                                    },
                                                    Raw {
                                                        content: "\" \"$out/bin/vivaldi\"\nmkdir -p \"$out/share\"\ncp -r usr/share/{applications,xfce4} \"$out\"/share\nsubstituteInPlace \"$out\"/share/applications/*.desktop \\\n  --replace /usr/bin/",
                                                        position: (76, 50),
                                                    },
                                                    Expression {
                                                        expression: Variable {
                                                            identifier: "vivaldiName",
                                                            position: (80, 28),
                                                        },
                                                    },
                                                    Raw {
                                                        content: " \"$out\"/bin/vivaldi\nsubstituteInPlace \"$out\"/share/applications/*.desktop \\\n  --replace vivaldi-stable vivaldi\nlocal d\nfor d in 16 22 24 32 48 64 128 256; do\n  mkdir -p \"$out\"/share/icons/hicolor/",
                                                        position: (80, 40),
                                                    },
                                                    Raw {
                                                        content: "$",
                                                        position: (85, 43),
                                                    },
                                                    Raw {
                                                        content: "{d}x",
                                                        position: (85, 46),
                                                    },
                                                    Raw {
                                                        content: "$",
                                                        position: (85, 50),
                                                    },
                                                    Raw {
                                                        content: "{d}/apps\n  ln -s \\\n    \"$out\"/opt/",
                                                        position: (85, 53),
                                                    },
                                                    Expression {
                                                        expression: Variable {
                                                            identifier: "vivaldiName",
                                                            position: (87, 22),
                                                        },
                                                    },
                                                    Raw {
                                                        content: "/product_logo_",
                                                        position: (87, 34),
                                                    },
                                                    Raw {
                                                        content: "$",
                                                        position: (87, 48),
                                                    },
                                                    Raw {
                                                        content: "{d}.png \\\n    \"$out\"/share/icons/hicolor/",
                                                        position: (87, 51),
                                                    },
                                                    Raw {
                                                        content: "$",
                                                        position: (88, 36),
                                                    },
                                                    Raw {
                                                        content: "{d}x",
                                                        position: (88, 39),
                                                    },
                                                    Raw {
                                                        content: "$",
                                                        position: (88, 43),
                                                    },
                                                    Raw {
                                                        content: "{d}/apps/vivaldi.png\ndone\nwrapProgram \"$out/bin/vivaldi\" \\\n  --add-flags ",
                                                        position: (88, 46),
                                                    },
                                                    Expression {
                                                        expression: FunctionApplication {
                                                            function: PropertyAccess {
                                                                expression: Variable {
                                                                    identifier: "lib",
                                                                    position: (91, 21),
                                                                },
                                                                attribute_path: AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "escapeShellArg",
                                                                            position: (91, 25),
                                                                        },
                                                                    ],
                                                                },
                                                                default: None,
                                                            },
                                                            arguments: [
                                                                Variable {
                                                                    identifier: "commandLineArgs",
                                                                    position: (91, 40),
                                                                },
                                                            ],
                                                        },
                                                    },
                                                    Raw {
                                                        content: " \\\n  --suffix XDG_DATA_DIRS : ",
                                                        position: (91, 56),
                                                    },
                                                    Expression {
                                                        expression: Variable {
                                                            identifier: "gtk3",
                                                            position: (92, 34),
                                                        },
                                                    },
                                                    Raw {
                                                        content: "/share/gsettings-schemas/",
                                                        position: (92, 39),
                                                    },
                                                    Expression {
                                                        expression: PropertyAccess {
                                                            expression: Variable {
                                                                identifier: "gtk3",
                                                                position: (92, 66),
                                                            },
                                                            attribute_path: AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "name",
                                                                        position: (92, 71),
                                                                    },
                                                                ],
                                                            },
                                                            default: None,
                                                        },
                                                    },
                                                    Raw {
                                                        content: "/ \\\n  ",
                                                        position: (92, 76),
                                                    },
                                                    Expression {
                                                        expression: FunctionApplication {
                                                            function: PropertyAccess {
                                                                expression: Variable {
                                                                    identifier: "lib",
                                                                    position: (93, 9),
                                                                },
                                                                attribute_path: AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "optionalString",
                                                                            position: (93, 13),
                                                                        },
                                                                    ],
                                                                },
                                                                default: None,
                                                            },
                                                            arguments: [
                                                                Variable {
                                                                    identifier: "enableWidevine",
                                                                    position: (93, 28),
                                                                },
                                                                String {
                                                                    parts: [
                                                                        Raw {
                                                                            content: "--suffix LD_LIBRARY_PATH : ",
                                                                            position: (93, 44),
                                                                        },
                                                                        Expression {
                                                                            expression: Variable {
                                                                                identifier: "libPath",
                                                                                position: (93, 73),
                                                                            },
                                                                        },
                                                                    ],
                                                                },
                                                            ],
                                                        },
                                                    },
                                                    Raw {
                                                        content: "\n",
                                                        position: (93, 83),
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (94, 8),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optionalString",
                                                                position: (94, 12),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "enableWidevine",
                                                        position: (94, 27),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "ln -sf ",
                                                                position: (95, 1),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "vivaldi-widevine",
                                                                    position: (95, 14),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/share/google/chrome/WidevineCdm $out/opt/",
                                                                position: (95, 31),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "vivaldiName",
                                                                    position: (95, 75),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/WidevineCdm\n",
                                                                position: (95, 87),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "runHook postInstall\n",
                                                position: (97, 1),
                                            },
                                        ],
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "meta",
                                        position: (100, 3),
                                    },
                                ],
                            },
                            With {
                                expression: Variable {
                                    identifier: "lib",
                                    position: (100, 15),
                                },
                                target: Map {
                                    bindings: [
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "description",
                                                        position: (101, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "A Browser for our Friends, powerful and personal",
                                                        position: (101, 20),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "homepage",
                                                        position: (102, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "https://vivaldi.com",
                                                        position: (102, 20),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "license",
                                                        position: (103, 5),
                                                    },
                                                ],
                                            },
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "licenses",
                                                    position: (103, 19),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "unfree",
                                                            position: (103, 28),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "maintainers",
                                                        position: (104, 5),
                                                    },
                                                ],
                                            },
                                            With {
                                                expression: Variable {
                                                    identifier: "maintainers",
                                                    position: (104, 24),
                                                },
                                                target: List {
                                                    elements: [
                                                        Variable {
                                                            identifier: "otwieracz",
                                                            position: (104, 39),
                                                        },
                                                        Variable {
                                                            identifier: "badmutex",
                                                            position: (104, 49),
                                                        },
                                                    ],
                                                },
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "platforms",
                                                        position: (105, 5),
                                                    },
                                                ],
                                            },
                                            List {
                                                elements: [
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "x86_64-linux",
                                                                position: (105, 22),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        ),
                                    ],
                                    recursive: false,
                                },
                            },
                        ),
                    ],
                    recursive: true,
                },
            ],
        },
    },
}