---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (6, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfge",
        position: (10, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (10, 10),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "environment",
         position: (10, 17),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (12, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (12, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "programs",
         position: (12, 16),
        },
        Raw {
         content: "bash",
         position: (12, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "bashAliases",
        position: (14, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "concatStringsSep",
       position: (14, 17),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "\n",
          position: (14, 35),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mapAttrsFlatten",
         position: (15, 5),
        },
        arguments: [
         Function {
          argument: Some(
           "k",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "v",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: String {
            parts: [
             Raw {
              content: "alias ",
              position: (15, 29),
             },
             Expression {
              expression: Variable {
               identifier: "k",
               position: (15, 37),
              },
             },
             Raw {
              content: "=",
              position: (15, 39),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "escapeShellArg",
                position: (15, 42),
               },
               arguments: [
                Variable {
                 identifier: "v",
                 position: (15, 57),
                },
               ],
              },
             },
            ],
           },
           position: (15, 25),
          },
          position: (15, 22),
         },
         FunctionApplication {
          function: Variable {
           identifier: "filterAttrs",
           position: (16, 8),
          },
          arguments: [
           Function {
            argument: Some(
             "k",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "v",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               Variable {
                identifier: "v",
                position: (16, 27),
               },
               Variable {
                identifier: "null",
                position: (16, 32),
               },
              ],
              position: (16, 29),
             },
             position: (16, 24),
            },
            position: (16, 21),
           },
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (16, 38),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "shellAliases",
               position: (16, 42),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ],
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (22, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (23, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "programs",
               position: (23, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "bash",
               position: (23, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "enable",
               position: (23, 49),
              },
             ],
            },
           ],
           position: (23, 28),
          },
          String {
           parts: [],
          },
         ],
        },
       ],
       position: (22, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (26, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "programs",
            position: (28, 5),
           },
           Raw {
            content: "bash",
            position: (28, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "shellAliases",
               position: (45, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (45, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (46, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (46, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (47, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Set of aliases for bash shell, which overrides <option>environment.shellAliases</option>.\nSee <option>environment.shellAliases</option> for an option format description.\n",
                    position: (48, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (51, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (51, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (51, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "nullOr",
                      position: (51, 37),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "either",
                        position: (51, 45),
                       },
                       arguments: [
                        Variable {
                         identifier: "str",
                         position: (51, 52),
                        },
                        Variable {
                         identifier: "path",
                         position: (51, 56),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                  },
                  position: (51, 16),
                 },
                ),
               ],
               recursive: false,
               position: (45, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "shellInit",
               position: (54, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (54, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (55, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (56, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell script code called during bash shell initialisation.\n",
                    position: (57, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (59, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (59, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (59, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (54, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "loginShellInit",
               position: (62, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (62, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (63, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (64, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell script code called during login bash shell initialisation.\n",
                    position: (65, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (67, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (67, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (67, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (62, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "interactiveShellInit",
               position: (70, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (70, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (71, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (72, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell script code called during interactive bash shell initialisation.\n",
                    position: (73, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (75, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (75, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (75, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (70, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "promptInit",
               position: (78, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (78, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (79, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "# Provide a nice prompt if the terminal supports it.\nif [ \"$TERM\" != \"dumb\" ] || [ -n \"$INSIDE_EMACS\" ]; then\n  PROMPT_COLOR=\"1;31m\"\n  ((UID)) && PROMPT_COLOR=\"1;32m\"\n  if [ -n \"$INSIDE_EMACS\" ] || [ \"$TERM\" = \"eterm\" ] || [ \"$TERM\" = \"eterm-color\" ]; then\n    # Emacs term mode doesn't support xterm title escape sequence (\\e]0;)\n    PS1=\"\\n\\[\\033[$PROMPT_COLOR\\][\\u@\\h:\\w]\\\\$\\[\\033[0m\\] \"\n  else\n    PS1=\"\\n\\[\\033[$PROMPT_COLOR\\][\\[\\e]0;\\u@\\h: \\w\\a\\]\\u@\\h:\\w]\\\\$\\[\\033[0m\\] \"\n  fi\n  if test \"$TERM\" = \"xterm\"; then\n    PS1=\"\\[\\033]2;\\h:\\u:\\w\\007\\]$PS1\"\n  fi\nfi\n",
                    position: (80, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (95, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell script code used to initialise the bash prompt.\n",
                    position: (96, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (98, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (98, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (98, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (78, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "promptPluginInit",
               position: (101, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (101, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (102, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (103, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell script code used to initialise bash prompt plugins.\n",
                    position: (104, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (106, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (106, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (106, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "internal",
                    position: (107, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (107, 20),
                 },
                ),
               ],
               recursive: false,
               position: (101, 35),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (28, 21),
         },
        ),
       ],
       recursive: false,
       position: (26, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (114, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "programs",
            position: (116, 5),
           },
           Raw {
            content: "bash",
            position: (116, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "shellAliases",
               position: (118, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrs",
              position: (118, 22),
             },
             arguments: [
              Function {
               argument: Some(
                "name",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Variable {
                identifier: "mkDefault",
                position: (118, 38),
               },
               position: (118, 32),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfge",
                position: (118, 49),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "shellAliases",
                  position: (118, 54),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "shellInit",
               position: (120, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "if [ -z \"$__NIXOS_SET_ENVIRONMENT_DONE\" ]; then\n    . ",
               position: (121, 1),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (122, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "system",
                   position: (122, 24),
                  },
                  Raw {
                   content: "build",
                   position: (122, 31),
                  },
                  Raw {
                   content: "setEnvironment",
                   position: (122, 37),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\nfi\n\n",
               position: (122, 52),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfge",
                 position: (125, 11),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "shellInit",
                   position: (125, 16),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\n",
               position: (125, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "loginShellInit",
               position: (128, 7),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfge",
              position: (128, 24),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "loginShellInit",
                position: (128, 29),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "interactiveShellInit",
               position: (130, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "# Check the window size after every command.\nshopt -s checkwinsize\n\n# Disable hashing (i.e. caching) of command lookups.\nset +h\n\n",
               position: (131, 1),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (137, 11),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "promptInit",
                   position: (137, 15),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\n",
               position: (137, 26),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (138, 11),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "promptPluginInit",
                   position: (138, 15),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\n",
               position: (138, 32),
              },
              Expression {
               expression: Variable {
                identifier: "bashAliases",
                position: (139, 11),
               },
              },
              Raw {
               content: "\n\n",
               position: (139, 23),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfge",
                 position: (141, 11),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "interactiveShellInit",
                   position: (141, 16),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\n",
               position: (141, 37),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (116, 21),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (146, 5),
           },
           Raw {
            content: "etc",
            position: (146, 17),
           },
           Raw {
            content: "profile",
            position: (146, 21),
           },
           Raw {
            content: "text",
            position: (146, 29),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "# /etc/profile: DO NOT EDIT -- this file has been generated automatically.\n# This file is read for login shells.\n\n# Only execute this file once per shell.\nif [ -n \"$__ETC_PROFILE_SOURCED\" ]; then return; fi\n__ETC_PROFILE_SOURCED=1\n\n# Prevent this file from being sourced by interactive non-login child shells.\nexport __ETC_PROFILE_DONE=1\n\n",
            position: (148, 1),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (158, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "shellInit",
                position: (158, 15),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "\n",
            position: (158, 25),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (159, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "loginShellInit",
                position: (159, 15),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "\n\n# Read system-wide modifications.\nif test -f /etc/profile.local; then\n    . /etc/profile.local\nfi\n\nif [ -n \"",
            position: (159, 30),
           },
           Raw {
            content: "$",
            position: (166, 18),
           },
           Raw {
            content: "{BASH_VERSION:-}\" ]; then\n    . /etc/bashrc\nfi\n",
            position: (166, 21),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (171, 5),
           },
           Raw {
            content: "etc",
            position: (171, 17),
           },
           Raw {
            content: "bashrc",
            position: (171, 21),
           },
           Raw {
            content: "text",
            position: (171, 28),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "# /etc/bashrc: DO NOT EDIT -- this file has been generated automatically.\n\n# Only execute this file once per shell.\nif [ -n \"$__ETC_BASHRC_SOURCED\" ] || [ -n \"$NOSYSBASHRC\" ]; then return; fi\n__ETC_BASHRC_SOURCED=1\n\n# If the profile was not loaded in a parent process, source\n# it.  But otherwise don't do it because we don't want to\n# clobber overridden values of $PATH, etc.\nif [ -z \"$__ETC_PROFILE_DONE\" ]; then\n    . /etc/profile\nfi\n\n# We are not always an interactive shell.\nif [ -n \"$PS1\" ]; then\n    ",
            position: (173, 1),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (188, 15),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "interactiveShellInit",
                position: (188, 19),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "\nfi\n\n# Read system-wide modifications.\nif test -f /etc/bashrc.local; then\n    . /etc/bashrc.local\nfi\n",
            position: (188, 40),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (199, 5),
           },
           Raw {
            content: "etc",
            position: (199, 17),
           },
           Raw {
            content: "inputrc",
            position: (199, 21),
           },
           Raw {
            content: "source",
            position: (199, 29),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOptionDefault",
           position: (199, 38),
          },
          arguments: [
           Path {
            parts: [
             Raw {
              content: "./inputrc",
              position: (199, 54),
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (201, 5),
           },
           Raw {
            content: "defaultUserShell",
            position: (201, 11),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkDefault",
           position: (201, 30),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "pkgs",
             position: (201, 40),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "bashInteractive",
               position: (201, 45),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (203, 5),
           },
           Raw {
            content: "pathsToLink",
            position: (203, 17),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "optionals",
           position: (203, 31),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (203, 41),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "enableCompletion",
               position: (203, 45),
              },
             ],
            },
            default: None,
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "/etc/bash_completion.d",
                position: (204, 8),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "/share/bash-completion",
                position: (205, 8),
               },
              ],
             },
            ],
            position: (203, 62),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (208, 5),
           },
           Raw {
            content: "shells",
            position: (208, 17),
           },
          ],
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "/run/current-system/sw/bin/bash",
              position: (209, 10),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "/run/current-system/sw/bin/sh",
              position: (210, 10),
             },
            ],
           },
           String {
            parts: [
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (211, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bashInteractive",
                  position: (211, 17),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "/bin/bash",
              position: (211, 33),
             },
            ],
           },
           String {
            parts: [
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (212, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bashInteractive",
                  position: (212, 17),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "/bin/sh",
              position: (212, 33),
             },
            ],
           },
          ],
          position: (209, 7),
         },
        ),
       ],
       recursive: false,
       position: (114, 34),
      },
     ),
    ],
    recursive: false,
    position: (21, 1),
   },
   position: (8, 1),
  },
  position: (6, 1),
 },
 position: (4, 1),
}