---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: LetIn {
  bindings: [
   Inherit(
    Some(
     Variable {
      identifier: "lib",
      position: (45, 12),
     },
    ),
    [
     Raw {
      content: "concatStringsSep",
      position: (46, 5),
     },
     Raw {
      content: "head",
      position: (47, 5),
     },
     Raw {
      content: "isAttrs",
      position: (48, 5),
     },
     Raw {
      content: "listToAttrs",
      position: (49, 5),
     },
     Raw {
      content: "tail",
      position: (50, 5),
     },
    ],
   ),
  ],
  target: Map {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "textClosureList",
        position: (59, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "predefined",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "arg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "f",
             position: (61, 7),
            },
           ],
          },
          Function {
           argument: Some(
            "done",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "todo",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "todo",
                position: (62, 12),
               },
               List {
                elements: [],
                position: (62, 20),
               },
              ],
              position: (62, 17),
             },
             then: Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "result",
                   position: (62, 29),
                  },
                 ],
                },
                List {
                 elements: [],
                 position: (62, 38),
                },
               ),
               Inherit(
                None,
                [
                 Raw {
                  content: "done",
                  position: (62, 50),
                 },
                ],
               ),
              ],
              recursive: false,
              position: (62, 28),
             },
             else_: LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "entry",
                   position: (64, 15),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "head",
                  position: (64, 23),
                 },
                 arguments: [
                  Variable {
                   identifier: "todo",
                   position: (64, 28),
                  },
                 ],
                },
               ),
              ],
              target: IfThenElse {
               predicate: FunctionApplication {
                function: Variable {
                 identifier: "isAttrs",
                 position: (65, 14),
                },
                arguments: [
                 Variable {
                  identifier: "entry",
                  position: (65, 22),
                 },
                ],
               },
               then: LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "x",
                     position: (66, 17),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "f",
                    position: (66, 21),
                   },
                   arguments: [
                    Variable {
                     identifier: "done",
                     position: (66, 23),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "entry",
                      position: (66, 28),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "deps",
                        position: (66, 34),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "y",
                     position: (67, 17),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "f",
                    position: (67, 21),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "x",
                      position: (67, 23),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "done",
                        position: (67, 25),
                       },
                      ],
                     },
                     default: None,
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "tail",
                      position: (67, 31),
                     },
                     arguments: [
                      Variable {
                       identifier: "todo",
                       position: (67, 36),
                      },
                     ],
                    },
                   ],
                  },
                 ),
                ],
                target: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "result",
                      position: (68, 18),
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Concatenation,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "x",
                       position: (68, 27),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "result",
                         position: (68, 29),
                        },
                       ],
                      },
                      default: None,
                     },
                     BinaryOperation {
                      operator: Concatenation,
                      operands: [
                       List {
                        elements: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "entry",
                           position: (68, 40),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "text",
                             position: (68, 46),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                        position: (68, 39),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "y",
                         position: (68, 55),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "result",
                           position: (68, 57),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                      position: (68, 52),
                     },
                    ],
                    position: (68, 36),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "done",
                      position: (69, 18),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "y",
                     position: (69, 25),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "done",
                       position: (69, 27),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 ],
                 recursive: false,
                 position: (68, 16),
                },
                position: (66, 13),
               },
               else_: IfThenElse {
                predicate: HasProperty {
                 expression: Variable {
                  identifier: "done",
                  position: (71, 19),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Expression {
                    expression: Variable {
                     identifier: "entry",
                     position: (71, 28),
                    },
                   },
                  ],
                 },
                 position: (71, 24),
                },
                then: FunctionApplication {
                 function: Variable {
                  identifier: "f",
                  position: (71, 40),
                 },
                 arguments: [
                  Variable {
                   identifier: "done",
                   position: (71, 42),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "tail",
                    position: (71, 48),
                   },
                   arguments: [
                    Variable {
                     identifier: "todo",
                     position: (71, 53),
                    },
                   ],
                  },
                 ],
                },
                else_: FunctionApplication {
                 function: Variable {
                  identifier: "f",
                  position: (72, 16),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: Update,
                   operands: [
                    Variable {
                     identifier: "done",
                     position: (72, 19),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "listToAttrs",
                      position: (72, 27),
                     },
                     arguments: [
                      List {
                       elements: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "name",
                              position: (72, 41),
                             },
                            ],
                           },
                           Variable {
                            identifier: "entry",
                            position: (72, 48),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "value",
                              position: (72, 55),
                             },
                            ],
                           },
                           Int {
                            value: 1,
                            position: (72, 63),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (72, 40),
                        },
                       ],
                       position: (72, 39),
                      },
                     ],
                    },
                   ],
                   position: (72, 24),
                  },
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    List {
                     elements: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "predefined",
                        position: (72, 71),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Expression {
                          expression: Variable {
                           identifier: "entry",
                           position: (72, 84),
                          },
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                     position: (72, 70),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "tail",
                      position: (72, 95),
                     },
                     arguments: [
                      Variable {
                       identifier: "todo",
                       position: (72, 100),
                      },
                     ],
                    },
                   ],
                   position: (72, 92),
                  },
                 ],
                },
                position: (71, 16),
               },
               position: (65, 11),
              },
              position: (64, 11),
             },
             position: (62, 9),
            },
            position: (61, 17),
           },
           position: (61, 11),
          },
         ),
        ],
        target: PropertyAccess {
         expression: FunctionApplication {
          function: Variable {
           identifier: "f",
           position: (73, 9),
          },
          arguments: [
           Map {
            bindings: [],
            recursive: false,
            position: (73, 11),
           },
           Variable {
            identifier: "arg",
            position: (73, 14),
           },
          ],
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "result",
            position: (73, 19),
           },
          ],
         },
         default: None,
        },
        position: (60, 5),
       },
       position: (59, 33),
      },
      position: (59, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "textClosureMap",
        position: (75, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "f",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "predefined",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "names",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (76, 5),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "\n",
             position: (76, 23),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (76, 28),
           },
           arguments: [
            Variable {
             identifier: "f",
             position: (76, 32),
            },
            FunctionApplication {
             function: Variable {
              identifier: "textClosureList",
              position: (76, 35),
             },
             arguments: [
              Variable {
               identifier: "predefined",
               position: (76, 51),
              },
              Variable {
               identifier: "names",
               position: (76, 62),
              },
             ],
            },
           ],
          },
         ],
        },
        position: (75, 35),
       },
       position: (75, 23),
      },
      position: (75, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "noDepEntry",
        position: (78, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "text",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        Inherit(
         None,
         [
          Raw {
           content: "text",
           position: (78, 31),
          },
         ],
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "deps",
            position: (78, 37),
           },
          ],
         },
         List {
          elements: [],
          position: (78, 44),
         },
        ),
       ],
       recursive: false,
       position: (78, 22),
      },
      position: (78, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fullDepEntry",
        position: (79, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "text",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "deps",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         Inherit(
          None,
          [
           Raw {
            content: "text",
            position: (79, 39),
           },
           Raw {
            content: "deps",
            position: (79, 44),
           },
          ],
         ),
        ],
        recursive: false,
        position: (79, 30),
       },
       position: (79, 24),
      },
      position: (79, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "packEntry",
        position: (80, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "deps",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        Inherit(
         None,
         [
          Raw {
           content: "deps",
           position: (80, 30),
          },
         ],
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "text",
            position: (80, 36),
           },
          ],
         },
         String {
          parts: [],
         },
        ),
       ],
       recursive: false,
       position: (80, 21),
      },
      position: (80, 15),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "stringAfter",
        position: (82, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "deps",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "text",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         Inherit(
          None,
          [
           Raw {
            content: "text",
            position: (82, 39),
           },
           Raw {
            content: "deps",
            position: (82, 44),
           },
          ],
         ),
        ],
        recursive: false,
        position: (82, 29),
       },
       position: (82, 23),
      },
      position: (82, 17),
     },
    ),
   ],
   recursive: true,
   position: (53, 1),
  },
  position: (44, 1),
 },
 position: (1, 1),
}