---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "config",
    default: None,
   },
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "pkgs",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: LetIn {
  bindings: [
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "cfg",
       position: (4, 3),
      },
     ],
    },
    to: PropertyAccess {
     expression: Variable {
      identifier: "config",
      position: (4, 9),
     },
     attribute_path: AttributePath {
      parts: [
       Raw {
        content: "programs",
        position: (4, 16),
       },
       Raw {
        content: "captive-browser",
        position: (4, 25),
       },
      ],
     },
     default: None,
    },
   },
   Inherit {
    from: Some(
     Variable {
      identifier: "lib",
      position: (6, 12),
     },
    ),
    attributes: [
     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),
     },
    ],
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "browserDefault",
       position: (10, 3),
      },
     ],
    },
    to: Function {
     argument: Simple {
      identifier: "chromium",
     },
     definition: FunctionApplication {
      function: Variable {
       identifier: "concatStringsSep",
       position: (10, 30),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: " ",
          position: (10, 48),
         },
        ],
        position: (10, 47),
       },
       List {
        elements: [
         String {
          parts: [
           Raw {
            content: "env XDG_CONFIG_HOME=\"$PREV_CONFIG_HOME\"",
            position: (11, 7),
           },
          ],
          position: (11, 5),
         },
         String {
          parts: [
           Interpolation {
            expression: Variable {
             identifier: "chromium",
             position: (12, 9),
            },
           },
           Raw {
            content: "/bin/chromium",
            position: (12, 18),
           },
          ],
          position: (12, 5),
         },
         String {
          parts: [
           Raw {
            content: "--user-data-dir=",
            position: (13, 7),
           },
           Raw {
            content: "$",
            position: (13, 23),
           },
           Raw {
            content: "{XDG_DATA_HOME:-$HOME/.local/share}/chromium-captive",
            position: (13, 26),
           },
          ],
          position: (13, 5),
         },
         String {
          parts: [
           Raw {
            content: "--proxy-server=\"socks5://$PROXY\"",
            position: (14, 7),
           },
          ],
          position: (14, 5),
         },
         String {
          parts: [
           Raw {
            content: "--host-resolver-rules=\"MAP * ~NOTFOUND , EXCLUDE localhost\"",
            position: (15, 7),
           },
          ],
          position: (15, 5),
         },
         String {
          parts: [
           Raw {
            content: "--no-first-run",
            position: (16, 7),
           },
          ],
          position: (16, 5),
         },
         String {
          parts: [
           Raw {
            content: "--new-window",
            position: (17, 7),
           },
          ],
          position: (17, 5),
         },
         String {
          parts: [
           Raw {
            content: "--incognito",
            position: (18, 7),
           },
          ],
          position: (18, 5),
         },
         String {
          parts: [
           Raw {
            content: "-no-default-browser-check",
            position: (19, 7),
           },
          ],
          position: (19, 5),
         },
         String {
          parts: [
           Raw {
            content: "http://cache.nixos.org/",
            position: (20, 7),
           },
          ],
          position: (20, 5),
         },
        ],
        position: (10, 51),
       },
      ],
     },
     position: (10, 20),
    },
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "desktopItem",
       position: (23, 3),
      },
     ],
    },
    to: FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (23, 17),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "makeDesktopItem",
         position: (23, 22),
        },
       ],
      },
      default: None,
     },
     arguments: [
      Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "name",
            position: (24, 5),
           },
          ],
         },
         to: String {
          parts: [
           Raw {
            content: "captive-browser",
            position: (24, 13),
           },
          ],
          position: (24, 12),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "desktopName",
            position: (25, 5),
           },
          ],
         },
         to: String {
          parts: [
           Raw {
            content: "Captive Portal Browser",
            position: (25, 20),
           },
          ],
          position: (25, 19),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "exec",
            position: (26, 5),
           },
          ],
         },
         to: String {
          parts: [
           Raw {
            content: "/run/wrappers/bin/captive-browser",
            position: (26, 13),
           },
          ],
          position: (26, 12),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "icon",
            position: (27, 5),
           },
          ],
         },
         to: String {
          parts: [
           Raw {
            content: "nix-snowflake",
            position: (27, 13),
           },
          ],
          position: (27, 12),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "categories",
            position: (28, 5),
           },
          ],
         },
         to: List {
          elements: [
           String {
            parts: [
             Raw {
              content: "Network",
              position: (28, 21),
             },
            ],
            position: (28, 20),
           },
          ],
          position: (28, 18),
         },
        },
       ],
       recursive: false,
       position: (23, 38),
      },
     ],
    },
   },
  ],
  target: Map {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "options",
        position: (35, 3),
       },
      ],
     },
     to: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "programs",
           position: (36, 5),
          },
          Raw {
           content: "captive-browser",
           position: (36, 14),
          },
         ],
        },
        to: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "enable",
              position: (37, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkEnableOption",
             position: (37, 16),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "captive browser",
                position: (37, 32),
               },
              ],
              position: (37, 31),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "package",
              position: (39, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (39, 17),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (40, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (40, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "package",
                    position: (40, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (41, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (41, 19),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "captive-browser",
                    position: (41, 24),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "defaultText",
                   position: (42, 9),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "literalExpression",
                  position: (42, 23),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "pkgs.captive-browser",
                     position: (42, 42),
                    },
                   ],
                   position: (42, 41),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (43, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "Which package to use for captive-browser",
                   position: (43, 24),
                  },
                 ],
                 position: (43, 23),
                },
               },
              ],
              recursive: false,
              position: (39, 26),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "interface",
              position: (46, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (46, 19),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (47, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (47, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "str",
                    position: (47, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (48, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "your public network interface (wlp3s0, wlan0, eth0, ...)",
                   position: (48, 24),
                  },
                 ],
                 position: (48, 23),
                },
               },
              ],
              recursive: false,
              position: (46, 28),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "browser",
              position: (52, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (52, 17),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (53, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (53, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "str",
                    position: (53, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (54, 9),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "browserDefault",
                  position: (54, 19),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (54, 34),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "chromium",
                      position: (54, 39),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "defaultText",
                   position: (55, 9),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "literalExpression",
                  position: (55, 23),
                 },
                 arguments: [
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "browserDefault",
                     position: (55, 42),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "${pkgs.chromium}",
                        position: (55, 58),
                       },
                      ],
                      position: (55, 57),
                     },
                    ],
                   },
                   position: (55, 41),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (56, 9),
                  },
                 ],
                },
                to: 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: (57, 1),
                  },
                 ],
                 position: (56, 23),
                },
               },
              ],
              recursive: false,
              position: (52, 26),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "dhcp-dns",
              position: (70, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (70, 18),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (71, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (71, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "str",
                    position: (71, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (72, 9),
                  },
                 ],
                },
                to: 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: (73, 1),
                  },
                 ],
                 position: (72, 23),
                },
               },
              ],
              recursive: false,
              position: (70, 27),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "socks5-addr",
              position: (79, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (79, 21),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (80, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (80, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "str",
                    position: (80, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (81, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "localhost:1666",
                   position: (81, 20),
                  },
                 ],
                 position: (81, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (82, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "the listen address for the SOCKS5 proxy server",
                   position: (82, 24),
                  },
                 ],
                 position: (82, 23),
                },
               },
              ],
              recursive: false,
              position: (79, 30),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "bindInterface",
              position: (85, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (85, 23),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (86, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "true",
                 position: (86, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (87, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (87, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "bool",
                    position: (87, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (88, 9),
                  },
                 ],
                },
                to: 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: (89, 1),
                  },
                 ],
                 position: (88, 23),
                },
               },
              ],
              recursive: false,
              position: (85, 32),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (36, 32),
        },
       },
      ],
      recursive: false,
      position: (35, 13),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "config",
        position: (99, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "mkIf",
       position: (99, 12),
      },
      arguments: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (99, 17),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "enable",
           position: (99, 21),
          },
         ],
        },
        default: None,
       },
       Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "environment",
             position: (100, 5),
            },
            Raw {
             content: "systemPackages",
             position: (100, 17),
            },
           ],
          },
          to: List {
           elements: [
            Parentheses {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (101, 8),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "runCommandNoCC",
                  position: (101, 13),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "captive-browser-desktop-item",
                  position: (101, 29),
                 },
                ],
                position: (101, 28),
               },
               Map {
                bindings: [],
                recursive: false,
                position: (101, 59),
               },
               String {
                parts: [
                 Raw {
                  content: "install -Dm444 -t $out/share/applications ",
                  position: (102, 1),
                 },
                 Interpolation {
                  expression: Variable {
                   identifier: "desktopItem",
                   position: (102, 53),
                  },
                 },
                 Raw {
                  content: "/share/applications/*.desktop\n",
                  position: (102, 65),
                 },
                ],
                position: (101, 63),
               },
              ],
             },
             position: (101, 7),
            },
           ],
           position: (100, 34),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "programs",
             position: (106, 5),
            },
            Raw {
             content: "captive-browser",
             position: (106, 14),
            },
            Raw {
             content: "dhcp-dns",
             position: (106, 30),
            },
           ],
          },
          to: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "iface",
                position: (108, 9),
               },
              ],
             },
             to: Function {
              argument: Simple {
               identifier: "prefixes",
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "optionalString",
                position: (109, 11),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (109, 26),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "bindInterface",
                    position: (109, 30),
                   },
                  ],
                 },
                 default: None,
                },
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "escapeShellArgs",
                   position: (109, 45),
                  },
                  arguments: [
                   Parentheses {
                    expression: BinaryOperation {
                     operator: Concatenation,
                     operands: [
                      Variable {
                       identifier: "prefixes",
                       position: (109, 62),
                      },
                      List {
                       elements: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (109, 76),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "interface",
                            position: (109, 80),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                       position: (109, 74),
                      },
                     ],
                     position: (109, 71),
                    },
                    position: (109, 61),
                   },
                  ],
                 },
                 position: (109, 44),
                },
               ],
              },
              position: (108, 17),
             },
            },
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "mkOptionDefault",
             position: (111, 7),
            },
            arguments: [
             Parentheses {
              expression: IfThenElse {
               predicate: PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (112, 12),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "networking",
                   position: (112, 19),
                  },
                  Raw {
                   content: "networkmanager",
                   position: (112, 30),
                  },
                  Raw {
                   content: "enable",
                   position: (112, 45),
                  },
                 ],
                },
                default: None,
               },
               then: String {
                parts: [
                 Interpolation {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (113, 14),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "networkmanager",
                      position: (113, 19),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/bin/nmcli dev show ",
                  position: (113, 34),
                 },
                 Interpolation {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "iface",
                    position: (113, 56),
                   },
                   arguments: [
                    List {
                     elements: [],
                     position: (113, 62),
                    },
                   ],
                  },
                 },
                 Raw {
                  content: " | ",
                  position: (113, 65),
                 },
                 Interpolation {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (113, 70),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "gnugrep",
                      position: (113, 75),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/bin/fgrep IP4.DNS",
                  position: (113, 83),
                 },
                ],
                position: (113, 11),
               },
               else_: IfThenElse {
                predicate: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (114, 17),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "networking",
                    position: (114, 24),
                   },
                   Raw {
                    content: "dhcpcd",
                    position: (114, 35),
                   },
                   Raw {
                    content: "enable",
                    position: (114, 42),
                   },
                  ],
                 },
                 default: None,
                },
                then: String {
                 parts: [
                  Interpolation {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (115, 14),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "dhcpcd",
                       position: (115, 19),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/bin/dhcpcd ",
                   position: (115, 26),
                  },
                  Interpolation {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "iface",
                     position: (115, 40),
                    },
                    arguments: [
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "-U",
                          position: (115, 48),
                         },
                        ],
                        position: (115, 47),
                       },
                      ],
                      position: (115, 46),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: " | ",
                   position: (115, 53),
                  },
                  Interpolation {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (115, 58),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "gnugrep",
                       position: (115, 63),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/bin/fgrep domain_name_servers",
                   position: (115, 71),
                  },
                 ],
                 position: (115, 11),
                },
                else_: IfThenElse {
                 predicate: PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (116, 17),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "networking",
                     position: (116, 24),
                    },
                    Raw {
                     content: "useNetworkd",
                     position: (116, 35),
                    },
                   ],
                  },
                  default: None,
                 },
                 then: String {
                  parts: [
                   Interpolation {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (117, 14),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "package",
                        position: (117, 18),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/systemd-networkd-dns ",
                    position: (117, 26),
                   },
                   Interpolation {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "iface",
                      position: (117, 54),
                     },
                     arguments: [
                      List {
                       elements: [],
                       position: (117, 60),
                      },
                     ],
                    },
                   },
                  ],
                  position: (117, 11),
                 },
                 else_: String {
                  parts: [
                   Interpolation {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (119, 14),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "security",
                        position: (119, 21),
                       },
                       Raw {
                        content: "wrapperDir",
                        position: (119, 30),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/udhcpc --quit --now -f ",
                    position: (119, 41),
                   },
                   Interpolation {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "iface",
                      position: (119, 67),
                     },
                     arguments: [
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "-i",
                           position: (119, 75),
                          },
                         ],
                         position: (119, 74),
                        },
                       ],
                       position: (119, 73),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: " -O dns --script ",
                    position: (119, 80),
                   },
                   Interpolation {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (120, 11),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "writeShellScript",
                         position: (120, 16),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "udhcp-script",
                         position: (120, 34),
                        },
                       ],
                       position: (120, 33),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "if [ \"$1\" = bound ]; then\n  echo \"$dns\"\nfi\n",
                         position: (121, 1),
                        },
                       ],
                       position: (120, 48),
                      },
                     ],
                    },
                   },
                  ],
                  position: (119, 11),
                 },
                 position: (116, 14),
                },
                position: (114, 14),
               },
               position: (112, 9),
              },
              position: (111, 23),
             },
            ],
           },
           position: (107, 7),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "security",
             position: (127, 5),
            },
            Raw {
             content: "wrappers",
             position: (127, 14),
            },
            Raw {
             content: "udhcpc",
             position: (127, 23),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "owner",
                position: (128, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "root",
                position: (128, 16),
               },
              ],
              position: (128, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "group",
                position: (129, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "root",
                position: (129, 16),
               },
              ],
              position: (129, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "capabilities",
                position: (130, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "cap_net_raw+p",
                position: (130, 23),
               },
              ],
              position: (130, 22),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "source",
                position: (131, 7),
               },
              ],
             },
             to: String {
              parts: [
               Interpolation {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (131, 19),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "busybox",
                    position: (131, 24),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/bin/udhcpc",
                position: (131, 32),
               },
              ],
              position: (131, 16),
             },
            },
           ],
           recursive: false,
           position: (127, 32),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "security",
             position: (134, 5),
            },
            Raw {
             content: "wrappers",
             position: (134, 14),
            },
            Raw {
             content: "captive-browser",
             position: (134, 23),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "owner",
                position: (135, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "root",
                position: (135, 16),
               },
              ],
              position: (135, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "group",
                position: (136, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "root",
                position: (136, 16),
               },
              ],
              position: (136, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "capabilities",
                position: (137, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "cap_net_raw+p",
                position: (137, 23),
               },
              ],
              position: (137, 22),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "source",
                position: (138, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (138, 16),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "writeShellScript",
                  position: (138, 21),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "captive-browser",
                  position: (138, 39),
                 },
                ],
                position: (138, 38),
               },
               String {
                parts: [
                 Raw {
                  content: "export PREV_CONFIG_HOME=\"$XDG_CONFIG_HOME\"\nexport XDG_CONFIG_HOME=",
                  position: (139, 1),
                 },
                 Interpolation {
                  expression: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (140, 34),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "writeTextDir",
                       position: (140, 39),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "captive-browser.toml",
                       position: (140, 53),
                      },
                     ],
                     position: (140, 52),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "browser = \"\"\"",
                       position: (141, 1),
                      },
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (141, 50),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "browser",
                           position: (141, 54),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "\"\"\"\ndhcp-dns = \"\"\"",
                       position: (141, 62),
                      },
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (142, 51),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "dhcp-dns",
                           position: (142, 55),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "\"\"\"\nsocks5-addr = \"\"\"",
                       position: (142, 64),
                      },
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (143, 54),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "socks5-addr",
                           position: (143, 58),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "\"\"\"\n",
                       position: (143, 70),
                      },
                      Interpolation {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "optionalString",
                         position: (144, 37),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (144, 52),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "bindInterface",
                             position: (144, 56),
                            },
                           ],
                          },
                          default: None,
                         },
                         String {
                          parts: [
                           Raw {
                            content: "bind-device = \"\"\"",
                            position: (145, 1),
                           },
                           Interpolation {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (145, 56),
                             },
                             attribute_path: AttributePath {
                              parts: [
                               Raw {
                                content: "interface",
                                position: (145, 60),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: "\"\"\"\n",
                            position: (145, 70),
                           },
                          ],
                          position: (144, 70),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "\n",
                       position: (146, 38),
                      },
                     ],
                     position: (140, 75),
                    },
                   ],
                  },
                 },
                 Raw {
                  content: "\nexec ",
                  position: (147, 36),
                 },
                 Interpolation {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (148, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "package",
                      position: (148, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/bin/captive-browser\n",
                  position: (148, 28),
                 },
                ],
                position: (138, 56),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (134, 41),
          },
         },
        ],
        recursive: false,
        position: (99, 28),
       },
      ],
     },
    },
   ],
   recursive: false,
   position: (32, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}