---
LetIn {
 bindings: [
  KeyValue(
   AttributePath {
    attributes: [
     Raw {
      content: "minimalModulesWarning",
      position: (3, 3),
     },
    ],
   },
   FunctionApplication {
    function: Variable {
     identifier: "warn",
     position: (3, 27),
    },
    arguments: [
     String {
      parts: [
       Raw {
        content: "lib.nixos.evalModules is experimental and subject to change. See nixos/lib/default.nix",
        position: (3, 33),
       },
      ],
     },
     Variable {
      identifier: "null",
      position: (3, 121),
     },
    ],
   },
  ),
  Inherit(
   Some(
    Variable {
     identifier: "nonExtendedLib",
     position: (4, 12),
    },
   ),
   [
    Raw {
     content: "warn",
     position: (4, 28),
    },
   ],
  ),
  KeyValue(
   AttributePath {
    attributes: [
     Raw {
      content: "nonExtendedLib",
      position: (5, 3),
     },
    ],
   },
   FunctionApplication {
    function: Variable {
     identifier: "import",
     position: (5, 20),
    },
    arguments: [
     Path {
      parts: [
       Raw {
        content: "../../lib",
        position: (5, 27),
       },
      ],
     },
    ],
   },
  ),
 ],
 target: Function {
  argument: None,
  arguments: FunctionArguments {
   arguments: [
    FunctionArgument {
     identifier: "featureFlags",
     default: Some(
      Map {
       bindings: [],
       recursive: false,
       position: (12, 18),
      },
     ),
    },
    FunctionArgument {
     identifier: "lib",
     default: Some(
      Variable {
       identifier: "nonExtendedLib",
       position: (8, 9),
      },
     ),
    },
   ],
   ellipsis: true,
  },
  definition: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "seqIf",
        position: (19, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cond",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: Variable {
        identifier: "cond",
        position: (19, 20),
       },
       then: PropertyAccess {
        expression: Variable {
         identifier: "builtins",
         position: (19, 30),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "seq",
           position: (19, 39),
          },
         ],
        },
        default: None,
       },
       else_: Function {
        argument: Some(
         "a",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "b",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Variable {
          identifier: "b",
          position: (19, 54),
         },
         position: (19, 51),
        },
        position: (19, 48),
       },
       position: (19, 17),
      },
      position: (19, 11),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "seqAttrsIf",
        position: (21, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cond",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "a",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (21, 25),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "mapAttrs",
            position: (21, 29),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Function {
          argument: Some(
           "_",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "v",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "seqIf",
             position: (21, 45),
            },
            arguments: [
             Variable {
              identifier: "cond",
              position: (21, 51),
             },
             Variable {
              identifier: "a",
              position: (21, 56),
             },
             Variable {
              identifier: "v",
              position: (21, 58),
             },
            ],
           },
           position: (21, 42),
          },
          position: (21, 39),
         },
        ],
       },
       position: (21, 22),
      },
      position: (21, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "eval-config-minimal",
        position: (23, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "import",
       position: (23, 25),
      },
      arguments: [
       Path {
        parts: [
         Raw {
          content: "./eval-config-minimal.nix",
          position: (23, 32),
         },
        ],
       },
       Map {
        bindings: [
         Inherit(
          None,
          [
           Raw {
            content: "lib",
            position: (23, 68),
           },
          ],
         ),
        ],
        recursive: false,
        position: (23, 58),
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     Inherit(
      Some(
       FunctionApplication {
        function: Variable {
         identifier: "seqAttrsIf",
         position: (30, 12),
        },
        arguments: [
         UnaryOperation {
          operator: Not,
          operand: HasProperty {
           expression: Variable {
            identifier: "featureFlags",
            position: (30, 25),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "minimalModules",
              position: (30, 38),
             },
            ],
           },
           position: (30, 37),
          },
          position: (30, 24),
         },
         Variable {
          identifier: "minimalModulesWarning",
          position: (30, 54),
         },
         Variable {
          identifier: "eval-config-minimal",
          position: (30, 76),
         },
        ],
       },
      ),
      [
       Raw {
        content: "evalModules",
        position: (31, 5),
       },
      ],
     ),
    ],
    recursive: false,
    position: (29, 1),
   },
   position: (18, 1),
  },
  position: (7, 1),
 },
 position: (1, 1),
}