---
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: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 16),
        },
        Raw {
         content: "gitit",
         position: (7, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "homeDir",
        position: (9, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "/var/lib/gitit",
        position: (9, 14),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "toYesNo",
        position: (11, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "b",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: Variable {
        identifier: "b",
        position: (11, 19),
       },
       then: String {
        parts: [
         Raw {
          content: "yes",
          position: (11, 27),
         },
        ],
       },
       else_: String {
        parts: [
         Raw {
          content: "no",
          position: (11, 38),
         },
        ],
       },
       position: (11, 16),
      },
      position: (11, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gititShared",
        position: (13, 3),
       },
      ],
     },
     With {
      expression: PropertyAccess {
       expression: Variable {
        identifier: "cfg",
        position: (13, 22),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "haskellPackages",
          position: (13, 26),
         },
        ],
       },
       default: None,
      },
      target: BinaryOperation {
       operator: Addition,
       operands: [
        BinaryOperation {
         operator: Addition,
         operands: [
          BinaryOperation {
           operator: Addition,
           operands: [
            BinaryOperation {
             operator: Addition,
             operands: [
              BinaryOperation {
               operator: Addition,
               operands: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    BinaryOperation {
                     operator: Addition,
                     operands: [
                      Variable {
                       identifier: "gitit",
                       position: (13, 43),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/share/",
                         position: (13, 52),
                        },
                       ],
                      },
                     ],
                     position: (13, 49),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (13, 63),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stdenv",
                        position: (13, 68),
                       },
                       Raw {
                        content: "hostPlatform",
                        position: (13, 75),
                       },
                       Raw {
                        content: "system",
                        position: (13, 88),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (13, 61),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "-",
                     position: (13, 98),
                    },
                   ],
                  },
                 ],
                 position: (13, 95),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "ghc",
                  position: (13, 103),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "name",
                    position: (13, 107),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (13, 101),
              },
              String {
               parts: [
                Raw {
                 content: "/",
                 position: (13, 115),
                },
               ],
              },
             ],
             position: (13, 112),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "gitit",
              position: (13, 120),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "pname",
                position: (13, 126),
               },
              ],
             },
             default: None,
            },
           ],
           position: (13, 118),
          },
          String {
           parts: [
            Raw {
             content: "-",
             position: (13, 135),
            },
           ],
          },
         ],
         position: (13, 132),
        },
        PropertyAccess {
         expression: Variable {
          identifier: "gitit",
          position: (13, 140),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "version",
            position: (13, 146),
           },
          ],
         },
         default: None,
        },
       ],
       position: (13, 138),
      },
      position: (13, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gititWithPkgs",
        position: (15, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "hsPkgs",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "extras",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "hsPkgs",
          position: (15, 35),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "ghcWithPackages",
            position: (15, 42),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Function {
          argument: Some(
           "self",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: With {
           expression: Variable {
            identifier: "self",
            position: (15, 70),
           },
           target: BinaryOperation {
            operator: Concatenation,
            operands: [
             List {
              elements: [
               Variable {
                identifier: "gitit",
                position: (15, 78),
               },
              ],
              position: (15, 76),
             },
             FunctionApplication {
              function: Variable {
               identifier: "extras",
               position: (15, 90),
              },
              arguments: [
               Variable {
                identifier: "self",
                position: (15, 97),
               },
              ],
             },
            ],
            position: (15, 86),
           },
           position: (15, 65),
          },
          position: (15, 59),
         },
        ],
       },
       position: (15, 27),
      },
      position: (15, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gititSh",
        position: (17, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "hsPkgs",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "extras",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: With {
        expression: Variable {
         identifier: "pkgs",
         position: (17, 34),
        },
        target: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "env",
              position: (18, 5),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "gititWithPkgs",
             position: (18, 11),
            },
            arguments: [
             Variable {
              identifier: "hsPkgs",
              position: (18, 25),
             },
             Variable {
              identifier: "extras",
              position: (18, 32),
             },
            ],
           },
          ),
         ],
         target: FunctionApplication {
          function: Variable {
           identifier: "writeScript",
           position: (19, 6),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "gitit",
              position: (19, 19),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "#!",
              position: (20, 1),
             },
             Expression {
              expression: Variable {
               identifier: "runtimeShell",
               position: (20, 9),
              },
             },
             Raw {
              content: "\ncd $HOME\nexport NIX_GHC=\"",
              position: (20, 22),
             },
             Expression {
              expression: Variable {
               identifier: "env",
               position: (22, 23),
              },
             },
             Raw {
              content: "/bin/ghc\"\nexport NIX_GHCPKG=\"",
              position: (22, 27),
             },
             Expression {
              expression: Variable {
               identifier: "env",
               position: (23, 26),
              },
             },
             Raw {
              content: "/bin/ghc-pkg\"\nexport NIX_GHC_DOCDIR=\"",
              position: (23, 30),
             },
             Expression {
              expression: Variable {
               identifier: "env",
               position: (24, 30),
              },
             },
             Raw {
              content: "/share/doc/ghc/html\"\nexport NIX_GHC_LIBDIR=$( $NIX_GHC --print-libdir )\n",
              position: (24, 34),
             },
             Expression {
              expression: Variable {
               identifier: "env",
               position: (26, 7),
              },
             },
             Raw {
              content: "/bin/gitit -f ",
              position: (26, 11),
             },
             Expression {
              expression: Variable {
               identifier: "configFile",
               position: (26, 27),
              },
             },
             Raw {
              content: "\n",
              position: (26, 38),
             },
            ],
           },
          ],
         },
         position: (17, 40),
        },
        position: (17, 29),
       },
       position: (17, 21),
      },
      position: (17, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gititOptions",
        position: (29, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "enable",
           position: (31, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (31, 16),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (32, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (32, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (32, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (33, 9),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (33, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (34, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Enable the gitit service.",
                position: (34, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (31, 25),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "haskellPackages",
           position: (37, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (37, 25),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (38, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (38, 19),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "haskellPackages",
                 position: (38, 24),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "defaultText",
                position: (39, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "literalExpression",
               position: (39, 23),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "pkgs.haskellPackages",
                  position: (39, 42),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "example",
                position: (40, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "literalExpression",
               position: (40, 19),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "pkgs.haskell.packages.ghc784",
                  position: (40, 38),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (41, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "haskellPackages used to build gitit and plugins.",
                position: (41, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (37, 34),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "extraPackages",
           position: (44, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (44, 23),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (45, 9),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (45, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "functionTo",
                  position: (45, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (45, 34),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "listOf",
                    position: (45, 40),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (45, 47),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (45, 53),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (46, 9),
               },
              ],
             },
             Function {
              argument: Some(
               "self",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: List {
               elements: [],
               position: (46, 25),
              },
              position: (46, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "example",
                position: (47, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "literalExpression",
               position: (47, 19),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "haskellPackages: [\n  haskellPackages.wreq\n]\n",
                  position: (48, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (52, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Extra packages available to ghc when running gitit. The\nvalue must be a function which receives the attrset defined\nin <varname>haskellPackages</varname> as the sole argument.\n",
                position: (53, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (44, 32),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "address",
           position: (59, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (59, 17),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (60, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (60, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (60, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (61, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "0.0.0.0",
                position: (61, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (62, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "IP address on which the web server will listen.",
                position: (62, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (59, 26),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "port",
           position: (65, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (65, 14),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (66, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (66, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "int",
                 position: (66, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (67, 9),
               },
              ],
             },
             Int {
              value: 5001,
              position: (67, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (68, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Port on which the web server will run.",
                position: (68, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (65, 23),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "wikiTitle",
           position: (71, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (71, 19),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (72, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (72, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (72, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (73, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Gitit!",
                position: (73, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (74, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "The wiki title.",
                position: (74, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (71, 28),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "repositoryType",
           position: (77, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (77, 24),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (78, 9),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (78, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enum",
                  position: (78, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "git",
                    position: (78, 29),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "darcs",
                    position: (78, 35),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "mercurial",
                    position: (78, 43),
                   },
                  ],
                 },
                ],
                position: (78, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (79, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "git",
                position: (79, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (80, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the type of repository used for wiki content.",
                position: (80, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (77, 33),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "repositoryPath",
           position: (83, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (83, 24),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (84, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (84, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (84, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (85, 9),
               },
              ],
             },
             BinaryOperation {
              operator: Addition,
              operands: [
               Variable {
                identifier: "homeDir",
                position: (85, 19),
               },
               String {
                parts: [
                 Raw {
                  content: "/wiki",
                  position: (85, 30),
                 },
                ],
               },
              ],
              position: (85, 27),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (86, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the path of the repository directory. If it does not\nexist, gitit will create it on startup.\n",
                position: (87, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (83, 33),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "requireAuthentication",
           position: (92, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (92, 31),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (93, 9),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (93, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enum",
                  position: (93, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "none",
                    position: (93, 30),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "modify",
                    position: (93, 37),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "read",
                    position: (93, 46),
                   },
                  ],
                 },
                ],
                position: (93, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (94, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "modify",
                position: (94, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (95, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "If 'none', login is never required, and pages can be edited\nanonymously.  If 'modify', login is required to modify the wiki\n(edit, add, delete pages, upload files).  If 'read', login is\nrequired to see any wiki pages.\n",
                position: (96, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (92, 40),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "authenticationMethod",
           position: (103, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (103, 30),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (104, 9),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (104, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enum",
                  position: (104, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "form",
                    position: (104, 30),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "http",
                    position: (104, 37),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "generic",
                    position: (104, 44),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "github",
                    position: (104, 54),
                   },
                  ],
                 },
                ],
                position: (104, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (105, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "form",
                position: (105, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (106, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "'form' means that users will be logged in and registered using forms\nin the gitit web interface.  'http' means that gitit will assume that\nHTTP authentication is in place and take the logged in username from\nthe \"Authorization\" field of the HTTP request header (in addition,\nthe login/logout and registration links will be suppressed).\n'generic' means that gitit will assume that some form of\nauthentication is in place that directly sets REMOTE_USER to the name\nof the authenticated user (e.g. mod_auth_cas on apache).  'rpx' means\nthat gitit will attempt to log in through https://rpxnow.com.  This\nrequires that 'rpx-domain', 'rpx-key', and 'base-url' be set below,\nand that 'curl' be in the system path.\n",
                position: (107, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (103, 39),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "userFile",
           position: (121, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (121, 18),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (122, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (122, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (122, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (123, 9),
               },
              ],
             },
             BinaryOperation {
              operator: Addition,
              operands: [
               Variable {
                identifier: "homeDir",
                position: (123, 19),
               },
               String {
                parts: [
                 Raw {
                  content: "/gitit-users",
                  position: (123, 30),
                 },
                ],
               },
              ],
              position: (123, 27),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (124, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the path of the file containing user login information.  If\nit does not exist, gitit will create it (with an empty user list).\nThis file is not used if 'http' is selected for\nauthentication-method.\n",
                position: (125, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (121, 27),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "sessionTimeout",
           position: (132, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (132, 24),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (133, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (133, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "int",
                 position: (133, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (134, 9),
               },
              ],
             },
             Int {
              value: 60,
              position: (134, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (135, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Number of minutes of inactivity before a session expires.\n",
                position: (136, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (132, 33),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "staticDir",
           position: (140, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (140, 19),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (141, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (141, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (141, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (142, 9),
               },
              ],
             },
             BinaryOperation {
              operator: Addition,
              operands: [
               Variable {
                identifier: "gititShared",
                position: (142, 19),
               },
               String {
                parts: [
                 Raw {
                  content: "/data/static",
                  position: (142, 34),
                 },
                ],
               },
              ],
              position: (142, 31),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (143, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the path of the static directory (containing javascript,\ncss, and images).  If it does not exist, gitit will create it and\npopulate it with required scripts, stylesheets, and images.\n",
                position: (144, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (140, 28),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "defaultPageType",
           position: (150, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (150, 25),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (151, 9),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (151, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enum",
                  position: (151, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "markdown",
                    position: (151, 30),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "rst",
                    position: (151, 41),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "latex",
                    position: (151, 47),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "html",
                    position: (151, 55),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "markdown+lhs",
                    position: (151, 62),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "rst+lhs",
                    position: (151, 77),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "latex+lhs",
                    position: (151, 87),
                   },
                  ],
                 },
                ],
                position: (151, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (152, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "markdown",
                position: (152, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (153, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the type of markup used to interpret pages in the wiki.\nPossible values are markdown, rst, latex, html, markdown+lhs,\nrst+lhs, and latex+lhs. (the +lhs variants treat the input as\nliterate Haskell. See pandoc's documentation for more details.) If\nMarkdown is selected, pandoc's syntax extensions (for footnotes,\ndelimited code blocks, etc.) will be enabled. Note that pandoc's\nrestructuredtext parser is not complete, so some pages may not be\nrendered correctly if rst is selected. The same goes for latex and\nhtml.\n",
                position: (154, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (150, 34),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "math",
           position: (166, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (166, 14),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (167, 9),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (167, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enum",
                  position: (167, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "mathml",
                    position: (167, 30),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "raw",
                    position: (167, 39),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "mathjax",
                    position: (167, 45),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "jsmath",
                    position: (167, 55),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "google",
                    position: (167, 64),
                   },
                  ],
                 },
                ],
                position: (167, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (168, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "mathml",
                position: (168, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (169, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies how LaTeX math is to be displayed.  Possible values are\nmathml, raw, mathjax, jsmath, and google.  If mathml is selected,\ngitit will convert LaTeX math to MathML and link in a script,\nMathMLinHTML.js, that allows the MathML to be seen in Gecko browsers,\nIE + mathplayer, and Opera. In other browsers you may get a jumble of\ncharacters.  If raw is selected, the LaTeX math will be displayed as\nraw LaTeX math.  If mathjax is selected, gitit will link to the\nremote mathjax script.  If jsMath is selected, gitit will link to the\nscript /js/jsMath/easy/load.js, and will assume that jsMath has been\ninstalled into the js/jsMath directory.  This is the most portable\nsolution. If google is selected, the google chart API is called to\nrender the formula as an image. This requires a connection to google,\nand might raise a technical or a privacy problem.\n",
                position: (170, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (166, 23),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "mathJaxScript",
           position: (186, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (186, 23),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (187, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (187, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (187, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (188, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "https://d3eoax9i5htok0.cloudfront.net/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML",
                position: (188, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (189, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the path to MathJax rendering script.  You might want to\nuse your own MathJax script to render formulas without Internet\nconnection or if you want to use some special LaTeX packages.  Note:\npath specified there cannot be an absolute path to a script on your\nhdd, instead you should run your (local if you wish) HTTP server\nwhich will serve the MathJax.js script. You can easily (in four lines\nof code) serve MathJax.js using\nhttp://happstack.com/docs/crashcourse/FileServing.html Do not forget\nthe \"http://\" prefix (e.g. http://localhost:1234/MathJax.js).\n",
                position: (190, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (186, 32),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "showLhsBirdTracks",
           position: (202, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (202, 27),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (203, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (203, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (203, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (204, 9),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (204, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (205, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies whether to show Haskell code blocks in \"bird style\", with\n\"> \" at the beginning of each line.\n",
                position: (206, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (202, 36),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "templatesDir",
           position: (211, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (211, 22),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (212, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (212, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (212, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (213, 9),
               },
              ],
             },
             BinaryOperation {
              operator: Addition,
              operands: [
               Variable {
                identifier: "gititShared",
                position: (213, 19),
               },
               String {
                parts: [
                 Raw {
                  content: "/data/templates",
                  position: (213, 34),
                 },
                ],
               },
              ],
              position: (213, 31),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (214, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the path of the directory containing page templates.  If it\ndoes not exist, gitit will create it with default templates.  Users\nmay wish to edit the templates to customize the appearance of their\nwiki. The template files are HStringTemplate templates.  Variables to\nbe interpolated appear between $\\'s. Literal $\\'s must be\nbackslash-escaped.\n",
                position: (215, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (211, 31),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "logFile",
           position: (224, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (224, 17),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (225, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (225, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (225, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (226, 9),
               },
              ],
             },
             BinaryOperation {
              operator: Addition,
              operands: [
               Variable {
                identifier: "homeDir",
                position: (226, 19),
               },
               String {
                parts: [
                 Raw {
                  content: "/gitit.log",
                  position: (226, 30),
                 },
                ],
               },
              ],
              position: (226, 27),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (227, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the path of gitit's log file.  If it does not exist, gitit\nwill create it. The log is in Apache combined log format.\n",
                position: (228, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (224, 26),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "logLevel",
           position: (233, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (233, 18),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (234, 9),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (234, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enum",
                  position: (234, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "DEBUG",
                    position: (234, 30),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "INFO",
                    position: (234, 38),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "NOTICE",
                    position: (234, 45),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "WARNING",
                    position: (234, 54),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "ERROR",
                    position: (234, 64),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "CRITICAL",
                    position: (234, 72),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "ALERT",
                    position: (234, 83),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "EMERGENCY",
                    position: (234, 91),
                   },
                  ],
                 },
                ],
                position: (234, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (235, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "ERROR",
                position: (235, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (236, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Determines how much information is logged.  Possible values (from\nmost to least verbose) are DEBUG, INFO, NOTICE, WARNING, ERROR,\nCRITICAL, ALERT, EMERGENCY.\n",
                position: (237, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (233, 27),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "frontPage",
           position: (243, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (243, 19),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (244, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (244, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (244, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (245, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Front Page",
                position: (245, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (246, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies which wiki page is to be used as the wiki's front page.\nGitit creates a default front page on startup, if one does not exist\nalready.\n",
                position: (247, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (243, 28),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "noDelete",
           position: (253, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (253, 18),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (254, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (254, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (254, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (255, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Front Page, Help",
                position: (255, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (256, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies pages that cannot be deleted through the web interface.\n(They can still be deleted directly using git or darcs.) A\ncomma-separated list of page names.  Leave blank to allow every page\nto be deleted.\n",
                position: (257, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (253, 27),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "noEdit",
           position: (264, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (264, 16),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (265, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (265, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (265, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (266, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Help",
                position: (266, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (267, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies pages that cannot be edited through the web interface.\nLeave blank to allow every page to be edited.\n",
                position: (268, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (264, 25),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "defaultSummary",
           position: (273, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (273, 24),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (274, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (274, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (274, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (275, 9),
               },
              ],
             },
             String {
              parts: [],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (276, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies text to be used in the change description if the author\nleaves the \"description\" field blank.  If default-summary is blank\n(the default), the author will be required to fill in the description\nfield.\n",
                position: (277, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (273, 33),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "tableOfContents",
           position: (284, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (284, 25),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (285, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (285, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (285, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (286, 9),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (286, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (287, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies whether to print a tables of contents (with links to\nsections) on each wiki page.\n",
                position: (288, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (284, 34),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "plugins",
           position: (293, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (293, 17),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (294, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (294, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "listOf",
                position: (294, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (294, 35),
                },
               ],
              },
              position: (294, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (295, 9),
               },
              ],
             },
             List {
              elements: [
               BinaryOperation {
                operator: Addition,
                operands: [
                 Variable {
                  identifier: "gititShared",
                  position: (295, 22),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/plugins/Dot.hs",
                    position: (295, 37),
                   },
                  ],
                 },
                ],
                position: (295, 34),
               },
              ],
              position: (295, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (296, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies a list of plugins to load. Plugins may be specified either\nby their path or by their module name. If the plugin name starts\nwith Gitit.Plugin., gitit will assume that the plugin is an installed\nmodule and will not try to find a source file.\n",
                position: (297, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (293, 26),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "useCache",
           position: (304, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (304, 18),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (305, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (305, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (305, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (306, 9),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (306, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (307, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies whether to cache rendered pages.  Note that if use-feed is\nselected, feeds will be cached regardless of the value of use-cache.\n",
                position: (308, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (304, 27),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "cacheDir",
           position: (313, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (313, 18),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (314, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (314, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (314, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (315, 9),
               },
              ],
             },
             BinaryOperation {
              operator: Addition,
              operands: [
               Variable {
                identifier: "homeDir",
                position: (315, 19),
               },
               String {
                parts: [
                 Raw {
                  content: "/cache",
                  position: (315, 30),
                 },
                ],
               },
              ],
              position: (315, 27),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (316, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Path where rendered pages will be cached.",
                position: (316, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (313, 27),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "maxUploadSize",
           position: (319, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (319, 23),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (320, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (320, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (320, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (321, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "1000K",
                position: (321, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (322, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies an upper limit on the size (in bytes) of files uploaded\nthrough the wiki's web interface.  To disable uploads, set this to\n0K.  This will result in the uploads link disappearing and the\n_upload url becoming inactive.\n",
                position: (323, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (319, 32),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "maxPageSize",
           position: (330, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (330, 21),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (331, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (331, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (331, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (332, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "1000K",
                position: (332, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (333, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies an upper limit on the size (in bytes) of pages.",
                position: (333, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (330, 30),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "debugMode",
           position: (336, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (336, 19),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (337, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (337, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (337, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (338, 9),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (338, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (339, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Causes debug information to be logged while gitit is running.",
                position: (339, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (336, 28),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "compressResponses",
           position: (342, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (342, 27),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (343, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (343, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (343, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (344, 9),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (344, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (345, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies whether HTTP responses should be compressed.",
                position: (345, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (342, 36),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "mimeTypesFile",
           position: (348, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (348, 23),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (349, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (349, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (349, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (350, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "/etc/mime/types.info",
                position: (350, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (351, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "          Specifies the path of a file containing mime type mappings.  Each\n          line of the file should contain two fields, separated by whitespace.\n          The first field is the mime type, the second is a file extension.\n          For example:\n<programlisting>\nvideo/x-ms-wmx  wmx\n</programlisting>\n          If the file is not found, some simple defaults will be used.\n",
                position: (352, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (348, 32),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "useReCaptcha",
           position: (363, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (363, 22),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (364, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (364, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (364, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (365, 9),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (365, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (366, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "If true, causes gitit to use the reCAPTCHA service\n(http://recaptcha.net) to prevent bots from creating accounts.\n",
                position: (367, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (363, 31),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "reCaptchaPrivateKey",
           position: (372, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (372, 29),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (373, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (373, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (373, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (373, 35),
                },
               ],
              },
              position: (373, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (374, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (374, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (375, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the private key for the reCAPTCHA service.  To get\nthese, you need to create an account at http://recaptcha.net.\n",
                position: (376, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (372, 38),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "reCaptchaPublicKey",
           position: (381, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (381, 28),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (382, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (382, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (382, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (382, 35),
                },
               ],
              },
              position: (382, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (383, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (383, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (384, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the public key for the reCAPTCHA service.  To get\nthese, you need to create an account at http://recaptcha.net.\n",
                position: (385, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (381, 37),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "accessQuestion",
           position: (390, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (390, 24),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (391, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (391, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (391, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (392, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "What is the code given to you by Ms. X?",
                position: (392, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (393, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies a question that users must answer when they attempt to\ncreate an account\n",
                position: (394, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (390, 33),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "accessQuestionAnswers",
           position: (399, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (399, 31),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (400, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (400, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (400, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (401, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "RED DOG, red dog",
                position: (401, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (402, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies a question that users must answer when they attempt to\ncreate an account, along with a comma-separated list of acceptable\nanswers.  This can be used to institute a rudimentary password for\nsigning up as a user on the wiki, or as an alternative to reCAPTCHA.\nExample:\naccess-question:  What is the code given to you by Ms. X?\naccess-question-answers:  RED DOG, red dog\n",
                position: (403, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (399, 40),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "rpxDomain",
           position: (413, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (413, 19),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (414, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (414, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (414, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (414, 35),
                },
               ],
              },
              position: (414, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (415, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (415, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (416, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the domain and key of your RPX account.  The domain is just\nthe prefix of the complete RPX domain, so if your full domain is\n'https://foo.rpxnow.com/', use 'foo' as the value of rpx-domain.\n",
                position: (417, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (413, 28),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "rpxKey",
           position: (423, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (423, 16),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (424, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (424, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (424, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (424, 35),
                },
               ],
              },
              position: (424, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (425, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (425, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (426, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "RPX account access key.",
                position: (426, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (423, 25),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "mailCommand",
           position: (429, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (429, 21),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (430, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (430, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (430, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (431, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "sendmail %s",
                position: (431, 20),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (432, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies the command to use to send notification emails.  '%s' will\nbe replaced by the destination email address.  The body of the\nmessage will be read from stdin.  If this field is left blank,\npassword reset will not be offered.\n",
                position: (433, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (429, 30),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "resetPasswordMessage",
           position: (440, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (440, 30),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (441, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (441, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "lines",
                 position: (441, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (442, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "> From: gitit@$hostname$\n> To: $useremail$\n> Subject: Wiki password reset\n>\n> Hello $username$,\n>\n> To reset your password, please follow the link below:\n> http://$hostname$:$port$$resetlink$\n>\n> Regards\n",
                position: (443, 1),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (454, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Gives the text of the message that will be sent to the user should\nshe want to reset her password, or change other registration info.\nThe lines must be indented, and must begin with '>'.  The initial\nspaces and '> ' will be stripped off.  $username$ will be replaced by\nthe user's username, $useremail$ by her email address, $hostname$ by\nthe hostname on which the wiki is running (as returned by the\nhostname system call), $port$ by the port on which the wiki is\nrunning, and $resetlink$ by the relative path of a reset link derived\nfrom the user's existing hashed password. If your gitit wiki is being\nproxied to a location other than the root path of $port$, you should\nchange the link to reflect this: for example, to\nhttp://$hostname$/path/to/wiki$resetlink$ or\nhttp://gitit.$hostname$$resetlink$\n",
                position: (455, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (440, 39),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "useFeed",
           position: (471, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (471, 17),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (472, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (472, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (472, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (473, 9),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (473, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (474, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Specifies whether an ATOM feed should be enabled (for the site and\nfor individual pages).\n",
                position: (475, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (471, 26),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "baseUrl",
           position: (480, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (480, 17),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (481, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (481, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (481, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (481, 35),
                },
               ],
              },
              position: (481, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (482, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (482, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (483, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "The base URL of the wiki, to be used in constructing feed IDs and RPX\ntoken_urls.  Set this if useFeed is false or authentication-method\nis 'rpx'.\n",
                position: (484, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (480, 26),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "absoluteUrls",
           position: (490, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (490, 22),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (491, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (491, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (491, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (492, 9),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (492, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (493, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Make wikilinks absolute with respect to the base-url.  So, for\nexample, in a wiki served at the base URL '/wiki', on a page\nSub/Page, the wikilink '[Cactus]()' will produce a link to\n'/wiki/Cactus' if absoluteUrls is true, and a relative link to\n'Cactus' (referring to '/wiki/Sub/Cactus') if absolute-urls is 'no'.\n",
                position: (494, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (490, 31),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "feedDays",
           position: (502, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (502, 18),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (503, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (503, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "int",
                 position: (503, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (504, 9),
               },
              ],
             },
             Int {
              value: 14,
              position: (504, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (505, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Number of days to be included in feeds.",
                position: (505, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (502, 27),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "feedRefreshTime",
           position: (508, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (508, 25),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (509, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (509, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "int",
                 position: (509, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (510, 9),
               },
              ],
             },
             Int {
              value: 60,
              position: (510, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (511, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Number of minutes to cache feeds before refreshing.",
                position: (511, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (508, 34),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "pdfExport",
           position: (514, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (514, 19),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (515, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (515, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (515, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (516, 9),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (516, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (517, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "If true, PDF will appear in export options. PDF will be created using\npdflatex, which must be installed and in the path. Note that PDF\nexports create significant additional server load.\n",
                position: (518, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (514, 28),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "pandocUserData",
           position: (524, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (524, 24),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (525, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (525, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (525, 28),
               },
               arguments: [
                Variable {
                 identifier: "path",
                 position: (525, 35),
                },
               ],
              },
              position: (525, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (526, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (526, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (527, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "If a directory is specified, this will be searched for pandoc\ncustomizations. These can include a templates/ directory for custom\ntemplates for various export formats, an S5 directory for custom S5\nstyles, and a reference.odt for ODT exports. If no directory is\nspecified, $HOME/.pandoc will be searched. See pandoc's README for\nmore information.\n",
                position: (528, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (524, 33),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "xssSanitize",
           position: (537, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (537, 21),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (538, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (538, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (538, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (539, 9),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (539, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (540, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "If true, all HTML (including that produced by pandoc) is filtered\nthrough xss-sanitize.  Set to no only if you trust all of your users.\n",
                position: (541, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (537, 30),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "oauthClientId",
           position: (546, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (546, 23),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (547, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (547, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (547, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (547, 35),
                },
               ],
              },
              position: (547, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (548, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (548, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (549, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "OAuth client ID",
                position: (549, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (546, 32),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "oauthClientSecret",
           position: (552, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (552, 27),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (553, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (553, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (553, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (553, 35),
                },
               ],
              },
              position: (553, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (554, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (554, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (555, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "OAuth client secret",
                position: (555, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (552, 36),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "oauthCallback",
           position: (558, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (558, 23),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (559, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (559, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (559, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (559, 35),
                },
               ],
              },
              position: (559, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (560, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (560, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (561, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "OAuth callback URL",
                position: (561, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (558, 32),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "oauthAuthorizeEndpoint",
           position: (564, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (564, 32),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (565, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (565, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (565, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (565, 35),
                },
               ],
              },
              position: (565, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (566, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (566, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (567, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "OAuth authorize endpoint",
                position: (567, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (564, 41),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "oauthAccessTokenEndpoint",
           position: (570, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (570, 34),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (571, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (571, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (571, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (571, 35),
                },
               ],
              },
              position: (571, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (572, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (572, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (573, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "OAuth access token endpoint",
                position: (573, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (570, 43),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "githubOrg",
           position: (576, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (576, 19),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (577, 9),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "types",
               position: (577, 21),
              },
              target: FunctionApplication {
               function: Variable {
                identifier: "nullOr",
                position: (577, 28),
               },
               arguments: [
                Variable {
                 identifier: "str",
                 position: (577, 35),
                },
               ],
              },
              position: (577, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (578, 9),
               },
              ],
             },
             Variable {
              identifier: "null",
              position: (578, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (579, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Github organization",
                position: (579, 24),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (576, 28),
          },
         ],
        },
       ),
      ],
      recursive: false,
      position: (29, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configFile",
        position: (583, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (583, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (583, 21),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "gitit.conf",
          position: (583, 32),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "address: ",
          position: (584, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (584, 16),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "address",
              position: (584, 20),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nport: ",
          position: (584, 28),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (585, 13),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (585, 22),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (585, 26),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nwiki-title: ",
          position: (585, 31),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (586, 19),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "wikiTitle",
              position: (586, 23),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nrepository-type: ",
          position: (586, 33),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (587, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "repositoryType",
              position: (587, 28),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nrepository-path: ",
          position: (587, 43),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (588, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "repositoryPath",
              position: (588, 28),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nrequire-authentication: ",
          position: (588, 43),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (589, 31),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "requireAuthentication",
              position: (589, 35),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nauthentication-method: ",
          position: (589, 57),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (590, 30),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "authenticationMethod",
              position: (590, 34),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nuser-file: ",
          position: (590, 55),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (591, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "userFile",
              position: (591, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nsession-timeout: ",
          position: (591, 31),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (592, 24),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (592, 33),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "sessionTimeout",
                position: (592, 37),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nstatic-dir: ",
          position: (592, 52),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (593, 19),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "staticDir",
              position: (593, 23),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\ndefault-page-type: ",
          position: (593, 33),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (594, 26),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "defaultPageType",
              position: (594, 30),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nmath: ",
          position: (594, 46),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (595, 13),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "math",
              position: (595, 17),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nmathjax-script: ",
          position: (595, 22),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (596, 23),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "mathJaxScript",
              position: (596, 27),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nshow-lhs-bird-tracks: ",
          position: (596, 41),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (597, 29),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (597, 37),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "showLhsBirdTracks",
                position: (597, 41),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\ntemplates-dir: ",
          position: (597, 59),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (598, 22),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "templatesDir",
              position: (598, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nlog-file: ",
          position: (598, 39),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (599, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "logFile",
              position: (599, 21),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nlog-level: ",
          position: (599, 29),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (600, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "logLevel",
              position: (600, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nfront-page: ",
          position: (600, 31),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (601, 19),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "frontPage",
              position: (601, 23),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nno-delete: ",
          position: (601, 33),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (602, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "noDelete",
              position: (602, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nno-edit: ",
          position: (602, 31),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (603, 16),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "noEdit",
              position: (603, 20),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\ndefault-summary: ",
          position: (603, 27),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (604, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "defaultSummary",
              position: (604, 28),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\ntable-of-contents: ",
          position: (604, 43),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (605, 26),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (605, 34),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "tableOfContents",
                position: (605, 38),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nplugins: ",
          position: (605, 54),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (606, 16),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ",",
               position: (606, 34),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (606, 37),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "plugins",
                position: (606, 41),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nuse-cache: ",
          position: (606, 49),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (607, 18),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (607, 26),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "useCache",
                position: (607, 30),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\ncache-dir: ",
          position: (607, 39),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (608, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "cacheDir",
              position: (608, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nmax-upload-size: ",
          position: (608, 31),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (609, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "maxUploadSize",
              position: (609, 28),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nmax-page-size: ",
          position: (609, 42),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (610, 22),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "maxPageSize",
              position: (610, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\ndebug-mode: ",
          position: (610, 38),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (611, 19),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (611, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "debugMode",
                position: (611, 31),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\ncompress-responses: ",
          position: (611, 41),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (612, 27),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (612, 35),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "compressResponses",
                position: (612, 39),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nmime-types-file: ",
          position: (612, 57),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (613, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "mimeTypesFile",
              position: (613, 28),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nuse-recaptcha: ",
          position: (613, 42),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (614, 22),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (614, 30),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "useReCaptcha",
                position: (614, 34),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nrecaptcha-private-key: ",
          position: (614, 47),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (615, 30),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (615, 39),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "reCaptchaPrivateKey",
                position: (615, 43),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nrecaptcha-public-key: ",
          position: (615, 63),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (616, 29),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (616, 38),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "reCaptchaPublicKey",
                position: (616, 42),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\naccess-question: ",
          position: (616, 61),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (617, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "accessQuestion",
              position: (617, 28),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\naccess-question-answers: ",
          position: (617, 43),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (618, 32),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "accessQuestionAnswers",
              position: (618, 36),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nrpx-domain: ",
          position: (618, 58),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (619, 19),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (619, 28),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "rpxDomain",
                position: (619, 32),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nrpx-key: ",
          position: (619, 42),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (620, 16),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (620, 25),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "rpxKey",
                position: (620, 29),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nmail-command: ",
          position: (620, 36),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (621, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "mailCommand",
              position: (621, 25),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nreset-password-message: ",
          position: (621, 37),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (622, 31),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "resetPasswordMessage",
              position: (622, 35),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nuse-feed: ",
          position: (622, 56),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (623, 17),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (623, 25),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "useFeed",
                position: (623, 29),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nbase-url: ",
          position: (623, 37),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (624, 17),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (624, 26),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "baseUrl",
                position: (624, 30),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nabsolute-urls: ",
          position: (624, 38),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (625, 22),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (625, 30),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "absoluteUrls",
                position: (625, 34),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nfeed-days: ",
          position: (625, 47),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (626, 18),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (626, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "feedDays",
                position: (626, 31),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nfeed-refresh-time: ",
          position: (626, 40),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (627, 26),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (627, 35),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "feedRefreshTime",
                position: (627, 39),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\npdf-export: ",
          position: (627, 55),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (628, 19),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (628, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "pdfExport",
                position: (628, 31),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\npandoc-user-data: ",
          position: (628, 41),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (629, 25),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (629, 34),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "pandocUserData",
                position: (629, 38),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nxss-sanitize: ",
          position: (629, 53),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toYesNo",
            position: (630, 21),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (630, 29),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "xssSanitize",
                position: (630, 33),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n\n[Github]\noauthclientid: ",
          position: (630, 45),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (633, 22),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (633, 31),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "oauthClientId",
                position: (633, 35),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\noauthclientsecret: ",
          position: (633, 49),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (634, 26),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (634, 35),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "oauthClientSecret",
                position: (634, 39),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\noauthcallback: ",
          position: (634, 57),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (635, 22),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (635, 31),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "oauthCallback",
                position: (635, 35),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\noauthauthorizeendpoint: ",
          position: (635, 49),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (636, 31),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (636, 40),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "oauthAuthorizeEndpoint",
                position: (636, 44),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\noauthaccesstokenendpoint: ",
          position: (636, 67),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (637, 33),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (637, 42),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "oauthAccessTokenEndpoint",
                position: (637, 46),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\ngithub-org: ",
          position: (637, 71),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (638, 19),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (638, 28),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "githubOrg",
                position: (638, 32),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (638, 42),
         },
        ],
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (645, 3),
        },
        Raw {
         content: "services",
         position: (645, 11),
        },
        Raw {
         content: "gitit",
         position: (645, 20),
        },
       ],
      },
      Variable {
       identifier: "gititOptions",
       position: (645, 28),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (647, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (647, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (647, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (647, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (649, 5),
             },
             Raw {
              content: "users",
              position: (649, 11),
             },
             Raw {
              content: "gitit",
              position: (649, 17),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (650, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (650, 15),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "users",
                  position: (650, 22),
                 },
                 Raw {
                  content: "groups",
                  position: (650, 28),
                 },
                 Raw {
                  content: "gitit",
                  position: (650, 35),
                 },
                 Raw {
                  content: "name",
                  position: (650, 41),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (651, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Gitit user",
                 position: (651, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (652, 7),
                },
               ],
              },
              Variable {
               identifier: "homeDir",
               position: (652, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "createHome",
                 position: (653, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (653, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (654, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (654, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (654, 20),
                 },
                 Raw {
                  content: "uids",
                  position: (654, 24),
                 },
                 Raw {
                  content: "gitit",
                  position: (654, 29),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (649, 25),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (657, 5),
             },
             Raw {
              content: "groups",
              position: (657, 11),
             },
             Raw {
              content: "gitit",
              position: (657, 18),
             },
             Raw {
              content: "gid",
              position: (657, 24),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (657, 30),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "ids",
               position: (657, 37),
              },
              Raw {
               content: "gids",
               position: (657, 41),
              },
              Raw {
               content: "gitit",
               position: (657, 46),
              },
             ],
            },
            default: None,
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (659, 5),
             },
             Raw {
              content: "services",
              position: (659, 13),
             },
             Raw {
              content: "gitit",
              position: (659, 22),
             },
            ],
           },
           LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (660, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (660, 13),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (660, 22),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "ids",
                    position: (660, 29),
                   },
                   Raw {
                    content: "uids",
                    position: (660, 33),
                   },
                   Raw {
                    content: "gitit",
                    position: (660, 38),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "gid",
                 position: (661, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (661, 13),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (661, 22),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "ids",
                    position: (661, 29),
                   },
                   Raw {
                    content: "gids",
                    position: (661, 33),
                   },
                   Raw {
                    content: "gitit",
                    position: (661, 38),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
            ],
            target: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (663, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Git and Pandoc Powered Wiki",
                  position: (663, 22),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "after",
                  position: (664, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "network.target",
                    position: (664, 18),
                   },
                  ],
                 },
                ],
                position: (664, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "wantedBy",
                  position: (665, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "multi-user.target",
                    position: (665, 21),
                   },
                  ],
                 },
                ],
                position: (665, 18),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "path",
                  position: (666, 7),
                 },
                ],
               },
               With {
                expression: Variable {
                 identifier: "pkgs",
                 position: (666, 19),
                },
                target: BinaryOperation {
                 operator: Concatenation,
                 operands: [
                  List {
                   elements: [
                    Variable {
                     identifier: "curl",
                     position: (666, 27),
                    },
                   ],
                   position: (666, 25),
                  },
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "optional",
                      position: (667, 17),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (667, 26),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "pdfExport",
                          position: (667, 30),
                         },
                        ],
                       },
                       default: None,
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "texlive",
                        position: (667, 40),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "combined",
                          position: (667, 48),
                         },
                         Raw {
                          content: "scheme-basic",
                          position: (667, 57),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                    BinaryOperation {
                     operator: Concatenation,
                     operands: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "optional",
                        position: (668, 17),
                       },
                       arguments: [
                        BinaryOperation {
                         operator: EqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (668, 27),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "repositoryType",
                              position: (668, 31),
                             },
                            ],
                           },
                           default: None,
                          },
                          String {
                           parts: [
                            Raw {
                             content: "darcs",
                             position: (668, 50),
                            },
                           ],
                          },
                         ],
                         position: (668, 46),
                        },
                        Variable {
                         identifier: "darcs",
                         position: (668, 58),
                        },
                       ],
                      },
                      BinaryOperation {
                       operator: Concatenation,
                       operands: [
                        FunctionApplication {
                         function: Variable {
                          identifier: "optional",
                          position: (669, 17),
                         },
                         arguments: [
                          BinaryOperation {
                           operator: EqualTo,
                           operands: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (669, 27),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "repositoryType",
                                position: (669, 31),
                               },
                              ],
                             },
                             default: None,
                            },
                            String {
                             parts: [
                              Raw {
                               content: "mercurial",
                               position: (669, 50),
                              },
                             ],
                            },
                           ],
                           position: (669, 46),
                          },
                          Variable {
                           identifier: "mercurial",
                           position: (669, 62),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "optional",
                          position: (670, 17),
                         },
                         arguments: [
                          BinaryOperation {
                           operator: EqualTo,
                           operands: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (670, 27),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "repositoryType",
                                position: (670, 31),
                               },
                              ],
                             },
                             default: None,
                            },
                            String {
                             parts: [
                              Raw {
                               content: "git",
                               position: (670, 50),
                              },
                             ],
                            },
                           ],
                           position: (670, 46),
                          },
                          Variable {
                           identifier: "git",
                           position: (670, 56),
                          },
                         ],
                        },
                       ],
                       position: (670, 14),
                      },
                     ],
                     position: (669, 14),
                    },
                   ],
                   position: (668, 14),
                  },
                 ],
                 position: (667, 14),
                },
                position: (666, 14),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "preStart",
                  position: (672, 7),
                 },
                ],
               },
               LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "gm",
                     position: (673, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitit@",
                     position: (673, 15),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (673, 23),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "networking",
                         position: (673, 30),
                        },
                        Raw {
                         content: "hostName",
                         position: (673, 41),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                   ],
                  },
                 ),
                ],
                target: With {
                 expression: Variable {
                  identifier: "cfg",
                  position: (675, 12),
                 },
                 target: String {
                  parts: [
                   Raw {
                    content: "chown ",
                    position: (676, 1),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "uid",
                     position: (676, 17),
                    },
                   },
                   Raw {
                    content: ":",
                    position: (676, 21),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "gid",
                     position: (676, 24),
                    },
                   },
                   Raw {
                    content: " -R ",
                    position: (676, 28),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "homeDir",
                     position: (676, 34),
                    },
                   },
                   Raw {
                    content: "\nfor dir in ",
                    position: (676, 42),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "repositoryPath",
                     position: (677, 22),
                    },
                   },
                   Raw {
                    content: " ",
                    position: (677, 37),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "staticDir",
                     position: (677, 40),
                    },
                   },
                   Raw {
                    content: " ",
                    position: (677, 50),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "templatesDir",
                     position: (677, 53),
                    },
                   },
                   Raw {
                    content: " ",
                    position: (677, 66),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "cacheDir",
                     position: (677, 69),
                    },
                   },
                   Raw {
                    content: "\ndo\n  if [ ! -d $dir ]\n  then\n    mkdir -p $dir\n    find $dir -type d -exec chmod 0750 {} +\n    find $dir -type f -exec chmod 0640 {} +\n  fi\ndone\ncd ",
                    position: (677, 78),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "repositoryPath",
                     position: (686, 14),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (686, 29),
                   },
                   Expression {
                    expression: IfThenElse {
                     predicate: BinaryOperation {
                      operator: EqualTo,
                      operands: [
                       Variable {
                        identifier: "repositoryType",
                        position: (688, 14),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "darcs",
                          position: (688, 33),
                         },
                        ],
                       },
                      ],
                      position: (688, 29),
                     },
                     then: String {
                      parts: [
                       Raw {
                        content: "if [ ! -d _darcs ]\nthen\n  ",
                        position: (690, 1),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (692, 15),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "darcs",
                            position: (692, 20),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/darcs initialize\n  echo \"",
                        position: (692, 26),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "gm",
                         position: (693, 21),
                        },
                       },
                       Raw {
                        content: "\" > _darcs/prefs/email\n",
                        position: (693, 24),
                       },
                      ],
                     },
                     else_: IfThenElse {
                      predicate: BinaryOperation {
                       operator: EqualTo,
                       operands: [
                        Variable {
                         identifier: "repositoryType",
                         position: (695, 19),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "mercurial",
                           position: (695, 38),
                          },
                         ],
                        },
                       ],
                       position: (695, 34),
                      },
                      then: String {
                       parts: [
                        Raw {
                         content: "          if [ ! -d .hg ]\n          then\n            ",
                         position: (697, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (699, 15),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mercurial",
                             position: (699, 20),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/hg init\n            cat >> .hg/hgrc <<NAMED\n[ui]\nusername = gitit ",
                         position: (699, 30),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "gm",
                          position: (702, 20),
                         },
                        },
                        Raw {
                         content: "\nNAMED\n          ",
                         position: (702, 23),
                        },
                       ],
                      },
                      else_: String {
                       parts: [
                        Raw {
                         content: "if [ ! -d  .git ]\nthen\n  ",
                         position: (707, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (709, 15),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "git",
                             position: (709, 20),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/git init\n  ",
                         position: (709, 24),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (710, 15),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "git",
                             position: (710, 20),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/git config user.email \"",
                         position: (710, 24),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "gm",
                          position: (710, 54),
                         },
                        },
                        Raw {
                         content: "\"\n  ",
                         position: (710, 57),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (711, 15),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "git",
                             position: (711, 20),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/git config user.name \"gitit\"\n",
                         position: (711, 24),
                        },
                       ],
                      },
                      position: (695, 16),
                     },
                     position: (688, 11),
                    },
                   },
                   Raw {
                    content: "\n  chown ",
                    position: (712, 14),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "uid",
                     position: (713, 19),
                    },
                   },
                   Raw {
                    content: ":",
                    position: (713, 23),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "gid",
                     position: (713, 26),
                    },
                   },
                   Raw {
                    content: " -R ",
                    position: (713, 30),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "repositoryPath",
                     position: (713, 36),
                    },
                   },
                   Raw {
                    content: "\n  fi\ncd -\n",
                    position: (713, 51),
                   },
                  ],
                 },
                 position: (675, 7),
                },
                position: (672, 18),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "serviceConfig",
                  position: (718, 7),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "User",
                     position: (719, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (719, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "users",
                      position: (719, 23),
                     },
                     Raw {
                      content: "users",
                      position: (719, 29),
                     },
                     Raw {
                      content: "gitit",
                      position: (719, 35),
                     },
                     Raw {
                      content: "name",
                      position: (719, 41),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "Group",
                     position: (720, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (720, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "users",
                      position: (720, 24),
                     },
                     Raw {
                      content: "groups",
                      position: (720, 30),
                     },
                     Raw {
                      content: "gitit",
                      position: (720, 37),
                     },
                     Raw {
                      content: "name",
                      position: (720, 43),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ExecStart",
                     position: (721, 9),
                    },
                   ],
                  },
                  With {
                   expression: Variable {
                    identifier: "cfg",
                    position: (721, 26),
                   },
                   target: FunctionApplication {
                    function: Variable {
                     identifier: "gititSh",
                     position: (721, 31),
                    },
                    arguments: [
                     Variable {
                      identifier: "haskellPackages",
                      position: (721, 39),
                     },
                     Variable {
                      identifier: "extraPackages",
                      position: (721, 55),
                     },
                    ],
                   },
                   position: (721, 21),
                  },
                 ),
                ],
                recursive: false,
                position: (718, 23),
               },
              ),
             ],
             recursive: false,
             position: (662, 8),
            },
            position: (659, 30),
           },
          ),
         ],
         recursive: false,
         position: (647, 28),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (643, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}