---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: LetIn {
  bindings: [
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "cfg",
       position: (4, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "config",
      position: (4, 9),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "programs",
        position: (4, 16),
       },
       Raw {
        content: "captive-browser",
        position: (4, 25),
       },
      ],
     },
     default: None,
    },
   ),
   Inherit(
    Some(
     Variable {
      identifier: "lib",
      position: (6, 12),
     },
    ),
    [
     Raw {
      content: "concatStringsSep",
      position: (7, 5),
     },
     Raw {
      content: "escapeShellArgs",
      position: (7, 22),
     },
     Raw {
      content: "optionalString",
      position: (7, 38),
     },
     Raw {
      content: "literalExpression",
      position: (8, 5),
     },
     Raw {
      content: "mkEnableOption",
      position: (8, 23),
     },
     Raw {
      content: "mkIf",
      position: (8, 38),
     },
     Raw {
      content: "mkOption",
      position: (8, 43),
     },
     Raw {
      content: "mkOptionDefault",
      position: (8, 52),
     },
     Raw {
      content: "types",
      position: (8, 68),
     },
    ],
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "browserDefault",
       position: (10, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "chromium",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: FunctionApplication {
      function: Variable {
       identifier: "concatStringsSep",
       position: (10, 30),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: " ",
         },
        ],
        position: (10, 47),
       },
       List {
        elements: [
         String {
          parts: [
           Raw {
            content: "env XDG_CONFIG_HOME=\"$PREV_CONFIG_HOME\"",
           },
          ],
          position: (11, 5),
         },
         String {
          parts: [
           Expression {
            expression: Variable {
             identifier: "chromium",
             position: (12, 9),
            },
           },
           Raw {
            content: "/bin/chromium",
           },
          ],
          position: (12, 5),
         },
         String {
          parts: [
           Raw {
            content: "--user-data-dir=",
           },
           Raw {
            content: "$",
           },
           Raw {
            content: "{XDG_DATA_HOME:-$HOME/.local/share}/chromium-captive",
           },
          ],
          position: (13, 5),
         },
         String {
          parts: [
           Raw {
            content: "--proxy-server=\"socks5://$PROXY\"",
           },
          ],
          position: (14, 5),
         },
         String {
          parts: [
           Raw {
            content: "--host-resolver-rules=\"MAP * ~NOTFOUND , EXCLUDE localhost\"",
           },
          ],
          position: (15, 5),
         },
         String {
          parts: [
           Raw {
            content: "--no-first-run",
           },
          ],
          position: (16, 5),
         },
         String {
          parts: [
           Raw {
            content: "--new-window",
           },
          ],
          position: (17, 5),
         },
         String {
          parts: [
           Raw {
            content: "--incognito",
           },
          ],
          position: (18, 5),
         },
         String {
          parts: [
           Raw {
            content: "-no-default-browser-check",
           },
          ],
          position: (19, 5),
         },
         String {
          parts: [
           Raw {
            content: "http://cache.nixos.org/",
           },
          ],
          position: (20, 5),
         },
        ],
        position: (10, 51),
       },
      ],
     },
     position: (10, 20),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "desktopItem",
       position: (23, 3),
      },
     ],
    },
    FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (23, 17),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "makeDesktopItem",
         position: (23, 22),
        },
       ],
      },
      default: None,
     },
     arguments: [
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "name",
            position: (24, 5),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "captive-browser",
           },
          ],
          position: (24, 12),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "desktopName",
            position: (25, 5),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "Captive Portal Browser",
           },
          ],
          position: (25, 19),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "exec",
            position: (26, 5),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "/run/wrappers/bin/captive-browser",
           },
          ],
          position: (26, 12),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "icon",
            position: (27, 5),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "nix-snowflake",
           },
          ],
          position: (27, 12),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "categories",
            position: (28, 5),
           },
          ],
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "Network",
             },
            ],
            position: (28, 20),
           },
          ],
          position: (28, 18),
         },
        ),
       ],
       recursive: false,
       position: (23, 38),
      },
     ],
    },
   ),
  ],
  target: Map {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "options",
        position: (35, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "programs",
           position: (36, 5),
          },
          Raw {
           content: "captive-browser",
           position: (36, 14),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "enable",
              position: (37, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkEnableOption",
             position: (37, 16),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "captive browser",
               },
              ],
              position: (37, 31),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "package",
              position: (39, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (39, 17),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (40, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (40, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "package",
                    position: (40, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (41, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (41, 19),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "captive-browser",
                    position: (41, 24),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "defaultText",
                   position: (42, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "literalExpression",
                  position: (42, 23),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "pkgs.captive-browser",
                    },
                   ],
                   position: (42, 41),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (43, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Which package to use for captive-browser",
                  },
                 ],
                 position: (43, 23),
                },
               ),
              ],
              recursive: false,
              position: (39, 26),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "interface",
              position: (46, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (46, 19),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (47, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (47, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "str",
                    position: (47, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (48, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "your public network interface (wlp3s0, wlan0, eth0, ...)",
                  },
                 ],
                 position: (48, 23),
                },
               ),
              ],
              recursive: false,
              position: (46, 28),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "browser",
              position: (52, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (52, 17),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (53, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (53, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "str",
                    position: (53, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (54, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "browserDefault",
                  position: (54, 19),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (54, 34),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "chromium",
                      position: (54, 39),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "defaultText",
                   position: (55, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "literalExpression",
                  position: (55, 23),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "browserDefault",
                    position: (55, 42),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "${pkgs.chromium}",
                      },
                     ],
                     position: (55, 57),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (56, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "The shell (/bin/sh) command executed once the proxy starts.\nWhen browser exits, the proxy exits. An extra env var PROXY is available.\n\nHere, we use a separate Chrome instance in Incognito mode, so that\nit can run (and be waited for) alongside the default one, and that\nit maintains no state across runs. To configure this browser open a\nnormal window in it, settings will be preserved.\n\n@volth: chromium is to open a plain HTTP (not HTTPS nor redirect to HTTPS!) website.\n        upstream uses http://example.com but I have seen captive portals whose DNS server resolves \"example.com\" to 127.0.0.1\n",
                  },
                 ],
                 position: (56, 23),
                },
               ),
              ],
              recursive: false,
              position: (52, 26),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "dhcp-dns",
              position: (70, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (70, 18),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (71, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (71, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "str",
                    position: (71, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (72, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "The shell (/bin/sh) command executed to obtain the DHCP\nDNS server address. The first match of an IPv4 regex is used.\nIPv4 only, because let's be real, it's a captive portal.\n",
                  },
                 ],
                 position: (72, 23),
                },
               ),
              ],
              recursive: false,
              position: (70, 27),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "socks5-addr",
              position: (79, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (79, 21),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (80, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (80, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "str",
                    position: (80, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (81, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "localhost:1666",
                  },
                 ],
                 position: (81, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (82, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "the listen address for the SOCKS5 proxy server",
                  },
                 ],
                 position: (82, 23),
                },
               ),
              ],
              recursive: false,
              position: (79, 30),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "bindInterface",
              position: (85, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (85, 23),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (86, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (86, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (87, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (87, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "bool",
                    position: (87, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (88, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Binds <package>captive-browser</package> to the network interface declared in\n<literal>cfg.interface</literal>. This can be used to avoid collisions\nwith private subnets.\n",
                  },
                 ],
                 position: (88, 23),
                },
               ),
              ],
              recursive: false,
              position: (85, 32),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (36, 32),
        },
       ),
      ],
      recursive: false,
      position: (35, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "config",
        position: (99, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkIf",
       position: (99, 12),
      },
      arguments: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (99, 17),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "enable",
           position: (99, 21),
          },
         ],
        },
        default: None,
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "environment",
             position: (100, 5),
            },
            Raw {
             content: "systemPackages",
             position: (100, 17),
            },
           ],
          },
          List {
           elements: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (101, 8),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "runCommandNoCC",
                 position: (101, 13),
                },
               ],
              },
              default: None,
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "captive-browser-desktop-item",
                },
               ],
               position: (101, 28),
              },
              Map {
               bindings: [],
               recursive: false,
               position: (101, 59),
              },
              String {
               parts: [
                Raw {
                 content: "install -Dm444 -t $out/share/applications ",
                },
                Expression {
                 expression: Variable {
                  identifier: "desktopItem",
                  position: (102, 53),
                 },
                },
                Raw {
                 content: "/share/applications/*.desktop\n",
                },
               ],
               position: (101, 63),
              },
             ],
            },
           ],
           position: (100, 34),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "programs",
             position: (106, 5),
            },
            Raw {
             content: "captive-browser",
             position: (106, 14),
            },
            Raw {
             content: "dhcp-dns",
             position: (106, 30),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "iface",
                position: (108, 9),
               },
              ],
             },
             Function {
              argument: Some(
               "prefixes",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "optionalString",
                position: (109, 11),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (109, 26),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "bindInterface",
                    position: (109, 30),
                   },
                  ],
                 },
                 default: None,
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "escapeShellArgs",
                  position: (109, 45),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    Variable {
                     identifier: "prefixes",
                     position: (109, 62),
                    },
                    List {
                     elements: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (109, 76),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "interface",
                          position: (109, 80),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                     position: (109, 74),
                    },
                   ],
                   position: (109, 71),
                  },
                 ],
                },
               ],
              },
              position: (108, 17),
             },
            ),
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "mkOptionDefault",
             position: (111, 7),
            },
            arguments: [
             IfThenElse {
              predicate: PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (112, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "networking",
                  position: (112, 19),
                 },
                 Raw {
                  content: "networkmanager",
                  position: (112, 30),
                 },
                 Raw {
                  content: "enable",
                  position: (112, 45),
                 },
                ],
               },
               default: None,
              },
              then: String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (113, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "networkmanager",
                     position: (113, 19),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/nmcli dev show ",
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "iface",
                   position: (113, 56),
                  },
                  arguments: [
                   List {
                    elements: [],
                    position: (113, 62),
                   },
                  ],
                 },
                },
                Raw {
                 content: " | ",
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (113, 70),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gnugrep",
                     position: (113, 75),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/fgrep IP4.DNS",
                },
               ],
               position: (113, 11),
              },
              else_: IfThenElse {
               predicate: PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (114, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "networking",
                   position: (114, 24),
                  },
                  Raw {
                   content: "dhcpcd",
                   position: (114, 35),
                  },
                  Raw {
                   content: "enable",
                   position: (114, 42),
                  },
                 ],
                },
                default: None,
               },
               then: String {
                parts: [
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (115, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "dhcpcd",
                      position: (115, 19),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/bin/dhcpcd ",
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "iface",
                    position: (115, 40),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "-U",
                        },
                       ],
                       position: (115, 47),
                      },
                     ],
                     position: (115, 46),
                    },
                   ],
                  },
                 },
                 Raw {
                  content: " | ",
                 },
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (115, 58),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "gnugrep",
                      position: (115, 63),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/bin/fgrep domain_name_servers",
                 },
                ],
                position: (115, 11),
               },
               else_: IfThenElse {
                predicate: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (116, 17),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "networking",
                    position: (116, 24),
                   },
                   Raw {
                    content: "useNetworkd",
                    position: (116, 35),
                   },
                  ],
                 },
                 default: None,
                },
                then: String {
                 parts: [
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (117, 14),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "package",
                       position: (117, 18),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/bin/systemd-networkd-dns ",
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "iface",
                     position: (117, 54),
                    },
                    arguments: [
                     List {
                      elements: [],
                      position: (117, 60),
                     },
                    ],
                   },
                  },
                 ],
                 position: (117, 11),
                },
                else_: String {
                 parts: [
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (119, 14),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (119, 21),
                      },
                      Raw {
                       content: "wrapperDir",
                       position: (119, 30),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/udhcpc --quit --now -f ",
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "iface",
                     position: (119, 67),
                    },
                    arguments: [
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "-i",
                         },
                        ],
                        position: (119, 74),
                       },
                      ],
                      position: (119, 73),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: " -O dns --script ",
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (120, 11),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "writeShellScript",
                        position: (120, 16),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "udhcp-script",
                       },
                      ],
                      position: (120, 33),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "if [ \"$1\" = bound ]; then\n  echo \"$dns\"\nfi\n",
                       },
                      ],
                      position: (120, 48),
                     },
                    ],
                   },
                  },
                 ],
                 position: (119, 11),
                },
                position: (116, 14),
               },
               position: (114, 14),
              },
              position: (112, 9),
             },
            ],
           },
           position: (107, 7),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "security",
             position: (127, 5),
            },
            Raw {
             content: "wrappers",
             position: (127, 14),
            },
            Raw {
             content: "udhcpc",
             position: (127, 23),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "owner",
                position: (128, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "root",
               },
              ],
              position: (128, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "group",
                position: (129, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "root",
               },
              ],
              position: (129, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "capabilities",
                position: (130, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "cap_net_raw+p",
               },
              ],
              position: (130, 22),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "source",
                position: (131, 7),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (131, 19),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "busybox",
                    position: (131, 24),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/bin/udhcpc",
               },
              ],
              position: (131, 16),
             },
            ),
           ],
           recursive: false,
           position: (127, 32),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "security",
             position: (134, 5),
            },
            Raw {
             content: "wrappers",
             position: (134, 14),
            },
            Raw {
             content: "captive-browser",
             position: (134, 23),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "owner",
                position: (135, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "root",
               },
              ],
              position: (135, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "group",
                position: (136, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "root",
               },
              ],
              position: (136, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "capabilities",
                position: (137, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "cap_net_raw+p",
               },
              ],
              position: (137, 22),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "source",
                position: (138, 7),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (138, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "writeShellScript",
                  position: (138, 21),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "captive-browser",
                 },
                ],
                position: (138, 38),
               },
               String {
                parts: [
                 Raw {
                  content: "export PREV_CONFIG_HOME=\"$XDG_CONFIG_HOME\"\nexport XDG_CONFIG_HOME=",
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (140, 34),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "writeTextDir",
                       position: (140, 39),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "captive-browser.toml",
                      },
                     ],
                     position: (140, 52),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "browser = \"\"\"",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (141, 50),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "browser",
                           position: (141, 54),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "\"\"\"\ndhcp-dns = \"\"\"",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (142, 51),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "dhcp-dns",
                           position: (142, 55),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "\"\"\"\nsocks5-addr = \"\"\"",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (143, 54),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "socks5-addr",
                           position: (143, 58),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "\"\"\"\n",
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "optionalString",
                         position: (144, 37),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (144, 52),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "bindInterface",
                             position: (144, 56),
                            },
                           ],
                          },
                          default: None,
                         },
                         String {
                          parts: [
                           Raw {
                            content: "bind-device = \"\"\"",
                           },
                           Expression {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (145, 56),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "interface",
                                position: (145, 60),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: "\"\"\"\n",
                           },
                          ],
                          position: (144, 70),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "\n",
                      },
                     ],
                     position: (140, 75),
                    },
                   ],
                  },
                 },
                 Raw {
                  content: "\nexec ",
                 },
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (148, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "package",
                      position: (148, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/bin/captive-browser\n",
                 },
                ],
                position: (138, 56),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (134, 41),
          },
         ),
        ],
        recursive: false,
        position: (99, 28),
       },
      ],
     },
    ),
   ],
   recursive: false,
   position: (32, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}