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