-module(glap@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/glap/parser.gleam").
-export([parser_print/1, show_help/1, parse/2, parse_argv/1]).
-export_type([parser/0]).

-type parser() :: {parser,
        list(glap@arguments:argument()),
        binary(),
        gleam@option:option(glap@parser_settings:parser_settings()),
        gleam@option:option(glap@help_settings:help_settings())}.

-file("src/glap/parser.gleam", 30).
-spec parser_print(parser()) -> nil.
parser_print(Parser) ->
    {parser, Args, Description, _, _} = Parser,
    gleam_stdlib:println(<<"Parser { "/utf8>>),
    gleam_stdlib:print(<<"\tdescription: "/utf8>>),
    gleam_stdlib:print(Description),
    gleam_stdlib:println(<<", "/utf8>>),
    gleam_stdlib:println(<<"\tcommands:"/utf8>>),
    gleam_stdlib:print(<<"\t\t"/utf8>>),
    _pipe = Args,
    _pipe@1 = gleam@list:map(_pipe, fun glap@arguments:argument_to_string/1),
    _pipe@2 = gleam@string:join(_pipe@1, <<"\n\t\t"/utf8>>),
    gleam_stdlib:println(_pipe@2),
    gleam_stdlib:println(<<" }"/utf8>>).

-file("src/glap/parser.gleam", 118).
-spec run_on_parse_error(glap@parser_settings:parser_settings()) -> nil.
run_on_parse_error(Settings) ->
    case erlang:element(3, Settings) of
        {some, F} ->
            F();

        none ->
            nil
    end.

-file("src/glap/parser.gleam", 157).
-spec parse_aux(
    list(binary()),
    list(glap@arguments:argument()),
    list(glap@arguments:argument()),
    list(glap@arguments:argument()),
    glap@parser_settings:parser_settings()
) -> {ok, list(glap@cliargs:c_l_i_arg())} |
    {error, {glap@error:parsing_error(), list(glap@arguments:argument())}}.
parse_aux(Args, Commands, Flags, Unnamed_arguments, Parser_settings) ->
    Arguments = gleam@list:flatten([Unnamed_arguments, Flags, Commands]),
    Required_flags = gleam@list:filter(
        Flags,
        fun(Flag) ->
            Required@1 = case Flag of
                {flag, _, _, _, Required, _} -> Required;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"glap/parser"/utf8>>,
                                function => <<"parse_aux"/utf8>>,
                                line => 168,
                                value => _assert_fail,
                                start => 4728,
                                'end' => 4782,
                                pattern_start => 4739,
                                pattern_end => 4775})
            end,
            Required@1
        end
    ),
    Required_commands = gleam@list:filter(
        Commands,
        fun(Command) ->
            Required@3 = case Command of
                {command, _, _, Required@2, _} -> Required@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"glap/parser"/utf8>>,
                                function => <<"parse_aux"/utf8>>,
                                line => 173,
                                value => _assert_fail@1,
                                start => 4862,
                                'end' => 4919,
                                pattern_start => 4873,
                                pattern_end => 4909})
            end,
            Required@3
        end
    ),
    Required_commands_str = begin
        _pipe = gleam@list:map(
            Required_commands,
            fun(Command@1) ->
                Name@1 = case Command@1 of
                    {command, Name, _, _, _} -> Name;
                    _assert_fail@2 ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                    file => <<?FILEPATH/utf8>>,
                                    module => <<"glap/parser"/utf8>>,
                                    function => <<"parse_aux"/utf8>>,
                                    line => 179,
                                    value => _assert_fail@2,
                                    start => 5013,
                                    'end' => 5066,
                                    pattern_start => 5024,
                                    pattern_end => 5056})
                end,
                Name@1
            end
        ),
        gleam@string:join(_pipe, <<" | "/utf8>>)
    end,
    gleam@bool:guard(
        ((Args =:= []) andalso (Required_commands /= [])) andalso erlang:element(
            2,
            Parser_settings
        ),
        {error,
            {{missing_command,
                    glap@utils:strformat(
                        <<"missing required command: {}"/utf8>>,
                        [Required_commands_str]
                    )},
                Arguments}},
        fun() ->
            gleam@bool:guard(
                ((Args =:= []) andalso (Unnamed_arguments /= [])) andalso erlang:element(
                    2,
                    Parser_settings
                ),
                begin
                    _pipe@2 = glap@utils:strformat(
                        <<"missing required flags: {}"/utf8>>,
                        [begin
                                _pipe@1 = gleam@list:map(
                                    Unnamed_arguments,
                                    fun(Cliarg) ->
                                        Name@3 = case Cliarg of
                                            {unnamed_argument, Name@2, _} -> Name@2;
                                            _assert_fail@3 ->
                                                erlang:error(
                                                        #{gleam_error => let_assert,
                                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                            file => <<?FILEPATH/utf8>>,
                                                            module => <<"glap/parser"/utf8>>,
                                                            function => <<"parse_aux"/utf8>>,
                                                            line => 197,
                                                            value => _assert_fail@3,
                                                            start => 5556,
                                                            'end' => 5610,
                                                            pattern_start => 5567,
                                                            pattern_end => 5601}
                                                    )
                                        end,
                                        Name@3
                                    end
                                ),
                                gleam@string:join(_pipe@1, <<", "/utf8>>)
                            end]
                    ),
                    _pipe@3 = {missing_required_flag, _pipe@2},
                    (fun(E) -> {error, {E, Arguments}} end)(_pipe@3)
                end,
                fun() ->
                    gleam@bool:guard(
                        Args =:= [],
                        {ok, []},
                        fun() ->
                            {H_args@1, Rest_args@1} = case Args of
                                [H_args | Rest_args] -> {H_args, Rest_args};
                                _assert_fail@4 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"glap/parser"/utf8>>,
                                                function => <<"parse_aux"/utf8>>,
                                                line => 209,
                                                value => _assert_fail@4,
                                                start => 5784,
                                                'end' => 5823,
                                                pattern_start => 5795,
                                                pattern_end => 5816})
                            end,
                            Should_be_flag = gleam_stdlib:string_starts_with(
                                H_args@1,
                                <<"-"/utf8>>
                            ),
                            case {Commands, Flags, Unnamed_arguments} of
                                {_,
                                    [{flag, Short, Long, _, _, Holds_value} |
                                        Rest_flag],
                                    _} when Should_be_flag ->
                                    gleam@bool:lazy_guard(
                                        not gleam_stdlib:string_starts_with(
                                            H_args@1,
                                            Short
                                        )
                                        andalso not gleam_stdlib:string_starts_with(
                                            H_args@1,
                                            Long
                                        ),
                                        fun() ->
                                            {
                                            H_flag@1,
                                                H2_flag@1,
                                                Rest_flag@2} = case Flags of
                                                [H_flag, H2_flag | Rest_flag@1] -> {
                                                H_flag,
                                                    H2_flag,
                                                    Rest_flag@1};
                                                _assert_fail@5 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                file => <<?FILEPATH/utf8>>,
                                                                module => <<"glap/parser"/utf8>>,
                                                                function => <<"parse_aux"/utf8>>,
                                                                line => 224,
                                                                value => _assert_fail@5,
                                                                start => 6404,
                                                                'end' => 6453,
                                                                pattern_start => 6415,
                                                                pattern_end => 6445}
                                                        )
                                            end,
                                            parse_aux(
                                                Args,
                                                Commands,
                                                [H2_flag@1 |
                                                    glap@utils:push_back(
                                                        Rest_flag@2,
                                                        H_flag@1
                                                    )],
                                                Unnamed_arguments,
                                                Parser_settings
                                            )
                                        end,
                                        fun() ->
                                            {Content, Rest_args2} = case Holds_value of
                                                true ->
                                                    case gleam@string:split_once(
                                                        H_args@1,
                                                        <<"="/utf8>>
                                                    ) of
                                                        {ok, {_, Value}} ->
                                                            {{some,
                                                                    gleam@string:trim(
                                                                        Value
                                                                    )},
                                                                Rest_args@1};

                                                        {error, nil} ->
                                                            {
                                                            Flag_content@1,
                                                                Rest@1} = case Rest_args@1 of
                                                                [Flag_content |
                                                                    Rest] -> {
                                                                Flag_content,
                                                                    Rest};
                                                                _assert_fail@6 ->
                                                                    erlang:error(
                                                                            #{gleam_error => let_assert,
                                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                                file => <<?FILEPATH/utf8>>,
                                                                                module => <<"glap/parser"/utf8>>,
                                                                                function => <<"parse_aux"/utf8>>,
                                                                                line => 238,
                                                                                value => _assert_fail@6,
                                                                                start => 6984,
                                                                                'end' => 7029,
                                                                                pattern_start => 6995,
                                                                                pattern_end => 7017}
                                                                        )
                                                            end,
                                                            {{some,
                                                                    Flag_content@1},
                                                                Rest@1}
                                                    end;

                                                false ->
                                                    {none, Rest_args@1}
                                            end,
                                            Flag_cliarg = {flag,
                                                Short,
                                                Long,
                                                Content},
                                            Rest_result_r = parse_aux(
                                                Rest_args2,
                                                Commands,
                                                Rest_flag,
                                                Unnamed_arguments,
                                                Parser_settings
                                            ),
                                            gleam@bool:guard(
                                                gleam@result:is_error(
                                                    Rest_result_r
                                                ),
                                                Rest_result_r,
                                                fun() ->
                                                    Rest_result@1 = case Rest_result_r of
                                                        {ok, Rest_result} -> Rest_result;
                                                        _assert_fail@7 ->
                                                            erlang:error(
                                                                    #{gleam_error => let_assert,
                                                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                        file => <<?FILEPATH/utf8>>,
                                                                        module => <<"glap/parser"/utf8>>,
                                                                        function => <<"parse_aux"/utf8>>,
                                                                        line => 253,
                                                                        value => _assert_fail@7,
                                                                        start => 7371,
                                                                        'end' => 7413,
                                                                        pattern_start => 7382,
                                                                        pattern_end => 7397}
                                                                )
                                                    end,
                                                    {ok,
                                                        [Flag_cliarg |
                                                            Rest_result@1]}
                                                end
                                            )
                                        end
                                    );

                                {_,
                                    _,
                                    [{unnamed_argument, Name@4, _} |
                                        Rest_unnamed_argument]} ->
                                    Unnamed_argument_cliarg = {unnamed_argument,
                                        Name@4,
                                        H_args@1},
                                    Rest_result_r@1 = parse_aux(
                                        Rest_args@1,
                                        Commands,
                                        Flags,
                                        Rest_unnamed_argument,
                                        Parser_settings
                                    ),
                                    gleam@bool:guard(
                                        gleam@result:is_error(Rest_result_r@1),
                                        Rest_result_r@1,
                                        fun() ->
                                            Rest_result@3 = case Rest_result_r@1 of
                                                {ok, Rest_result@2} -> Rest_result@2;
                                                _assert_fail@8 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                file => <<?FILEPATH/utf8>>,
                                                                module => <<"glap/parser"/utf8>>,
                                                                function => <<"parse_aux"/utf8>>,
                                                                line => 265,
                                                                value => _assert_fail@8,
                                                                start => 7870,
                                                                'end' => 7912,
                                                                pattern_start => 7881,
                                                                pattern_end => 7896}
                                                        )
                                            end,
                                            {ok,
                                                [Unnamed_argument_cliarg |
                                                    Rest_result@3]}
                                        end
                                    );

                                {[_ | _], _, _} when (Required_flags =/= []) andalso erlang:element(
                                    2,
                                    Parser_settings
                                ) ->
                                    _pipe@5 = glap@utils:strformat(
                                        <<"missing required flags: {}"/utf8>>,
                                        [begin
                                                _pipe@4 = gleam@list:map(
                                                    Required_flags,
                                                    fun(Cliarg@1) ->
                                                        {Short@2, Long@2} = case Cliarg@1 of
                                                            {flag,
                                                                Short@1,
                                                                Long@1,
                                                                _,
                                                                _,
                                                                _} -> {
                                                            Short@1,
                                                                Long@1};
                                                            _assert_fail@9 ->
                                                                erlang:error(
                                                                        #{gleam_error => let_assert,
                                                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                            file => <<?FILEPATH/utf8>>,
                                                                            module => <<"glap/parser"/utf8>>,
                                                                            function => <<"parse_aux"/utf8>>,
                                                                            line => 274,
                                                                            value => _assert_fail@9,
                                                                            start => 8236,
                                                                            'end' => 8292,
                                                                            pattern_start => 8247,
                                                                            pattern_end => 8283}
                                                                    )
                                                        end,
                                                        <<<<<<<<"["/utf8,
                                                                        Short@2/binary>>/binary,
                                                                    "|"/utf8>>/binary,
                                                                Long@2/binary>>/binary,
                                                            "]"/utf8>>
                                                    end
                                                ),
                                                gleam@string:join(
                                                    _pipe@4,
                                                    <<", "/utf8>>
                                                )
                                            end]
                                    ),
                                    _pipe@6 = {missing_required_flag, _pipe@5},
                                    (fun(E@1) -> {error, {E@1, Arguments}} end)(
                                        _pipe@6
                                    );

                                {[_ | _], _, _} when (Unnamed_arguments =/= []) andalso erlang:element(
                                    2,
                                    Parser_settings
                                ) ->
                                    _pipe@8 = glap@utils:strformat(
                                        <<"missing required flags: {}"/utf8>>,
                                        [begin
                                                _pipe@7 = gleam@list:map(
                                                    Unnamed_arguments,
                                                    fun(Cliarg@2) ->
                                                        Name@6 = case Cliarg@2 of
                                                            {unnamed_argument,
                                                                Name@5,
                                                                _} -> Name@5;
                                                            _assert_fail@10 ->
                                                                erlang:error(
                                                                        #{gleam_error => let_assert,
                                                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                            file => <<?FILEPATH/utf8>>,
                                                                            module => <<"glap/parser"/utf8>>,
                                                                            function => <<"parse_aux"/utf8>>,
                                                                            line => 287,
                                                                            value => _assert_fail@10,
                                                                            start => 8686,
                                                                            'end' => 8740,
                                                                            pattern_start => 8697,
                                                                            pattern_end => 8731}
                                                                    )
                                                        end,
                                                        Name@6
                                                    end
                                                ),
                                                gleam@string:join(
                                                    _pipe@7,
                                                    <<", "/utf8>>
                                                )
                                            end]
                                    ),
                                    _pipe@9 = {missing_required_flag, _pipe@8},
                                    (fun(E@2) -> {error, {E@2, Arguments}} end)(
                                        _pipe@9
                                    );

                                {[{command, Name@7, _, _, Subs} | Rest_command],
                                    _,
                                    _} ->
                                    gleam@bool:lazy_guard(
                                        H_args@1 /= Name@7,
                                        fun() ->
                                            parse_aux(
                                                Args,
                                                Rest_command,
                                                Flags,
                                                Unnamed_arguments,
                                                Parser_settings
                                            )
                                        end,
                                        fun() ->
                                            Subcommands = gleam@list:filter(
                                                Subs,
                                                fun glap@arguments:is_command/1
                                            ),
                                            Subflags = gleam@list:filter(
                                                Subs,
                                                fun glap@arguments:is_flag/1
                                            ),
                                            Subunnamedarguments = gleam@list:filter(
                                                Subs,
                                                fun glap@arguments:is_unnamed_argument/1
                                            ),
                                            Result_rest_r = parse_aux(
                                                Rest_args@1,
                                                Subcommands,
                                                Subflags,
                                                Subunnamedarguments,
                                                Parser_settings
                                            ),
                                            gleam@bool:guard(
                                                gleam@result:is_error(
                                                    Result_rest_r
                                                ),
                                                Result_rest_r,
                                                fun() ->
                                                    Rest_result@5 = case Result_rest_r of
                                                        {ok, Rest_result@4} -> Rest_result@4;
                                                        _assert_fail@11 ->
                                                            erlang:error(
                                                                    #{gleam_error => let_assert,
                                                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                        file => <<?FILEPATH/utf8>>,
                                                                        module => <<"glap/parser"/utf8>>,
                                                                        function => <<"parse_aux"/utf8>>,
                                                                        line => 308,
                                                                        value => _assert_fail@11,
                                                                        start => 9534,
                                                                        'end' => 9576,
                                                                        pattern_start => 9545,
                                                                        pattern_end => 9560}
                                                                )
                                                    end,
                                                    Command_cliarg = {command,
                                                        Name@7,
                                                        true,
                                                        Rest_result@5},
                                                    {ok, [Command_cliarg]}
                                                end
                                            )
                                        end
                                    );

                                {_, _, _} ->
                                    _pipe@10 = glap@utils:strformat(
                                        <<"argument '{}' unknown"/utf8>>,
                                        [H_args@1]
                                    ),
                                    _pipe@11 = {unknown_argument, _pipe@10},
                                    (fun(E@3) -> {error, {E@3, Arguments}} end)(
                                        _pipe@11
                                    )
                            end
                        end
                    )
                end
            )
        end
    ).

-file("src/glap/parser.gleam", 49).
-spec show_help_aux(
    list(glap@arguments:argument()),
    glap@help_settings:help_settings(),
    fun((binary()) -> nil),
    integer(),
    integer()
) -> nil.
show_help_aux(Args, Showhelp_settings, Printfun, Tabdesc_length, Indent_level) ->
    gleam@bool:guard(
        Args =:= [],
        nil,
        fun() ->
            {Args_h@1, Args_rest@1} = case Args of
                [Args_h | Args_rest] -> {Args_h, Args_rest};
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"glap/parser"/utf8>>,
                                function => <<"show_help_aux"/utf8>>,
                                line => 57,
                                value => _assert_fail,
                                start => 1200,
                                'end' => 1239,
                                pattern_start => 1211,
                                pattern_end => 1232})
            end,
            Indentstr = gleam@string:repeat(
                erlang:element(3, Showhelp_settings),
                Indent_level
            ),
            case Args_h@1 of
                {flag, _, _, _, _, _} ->
                    _pipe = glap@help_settings:format_argument_without_desc(
                        Args_h@1
                    ),
                    _pipe@1 = gleam@string:append(Indentstr, _pipe),
                    _pipe@2 = gleam@string:pad_end(
                        _pipe@1,
                        Tabdesc_length,
                        <<" "/utf8>>
                    ),
                    _pipe@3 = gleam@string:append(
                        _pipe@2,
                        <<(glap@arguments:get_description(Args_h@1))/binary,
                            "\n"/utf8>>
                    ),
                    Printfun(_pipe@3);

                {unnamed_argument, _, _} ->
                    _pipe@4 = glap@help_settings:format_argument_without_desc(
                        Args_h@1
                    ),
                    _pipe@5 = gleam@string:append(Indentstr, _pipe@4),
                    _pipe@6 = gleam@string:pad_end(
                        _pipe@5,
                        Tabdesc_length,
                        <<" "/utf8>>
                    ),
                    _pipe@7 = gleam@string:append(
                        _pipe@6,
                        <<(glap@arguments:get_description(Args_h@1))/binary,
                            "\n"/utf8>>
                    ),
                    Printfun(_pipe@7);

                {command, _, _, _, Subcommands} ->
                    case Indent_level < erlang:element(5, Showhelp_settings) of
                        true ->
                            Printfun(<<"\n"/utf8>>);

                        false ->
                            nil
                    end,
                    _pipe@8 = glap@help_settings:format_argument_without_desc(
                        Args_h@1
                    ),
                    _pipe@9 = gleam@string:append(Indentstr, _pipe@8),
                    _pipe@10 = gleam@string:pad_end(
                        _pipe@9,
                        Tabdesc_length,
                        <<" "/utf8>>
                    ),
                    _pipe@11 = gleam@string:append(
                        _pipe@10,
                        <<(glap@arguments:get_description(Args_h@1))/binary,
                            "\n"/utf8>>
                    ),
                    Printfun(_pipe@11),
                    case erlang:element(4, Showhelp_settings) of
                        true when Indent_level < erlang:element(
                            5,
                            Showhelp_settings
                        ) ->
                            show_help_aux(
                                Subcommands,
                                Showhelp_settings,
                                Printfun,
                                Tabdesc_length,
                                Indent_level + 1
                            );

                        _ ->
                            nil
                    end
            end,
            show_help_aux(
                Args_rest@1,
                Showhelp_settings,
                Printfun,
                Tabdesc_length,
                Indent_level
            )
        end
    ).

-file("src/glap/parser.gleam", 101).
-spec show_help(parser()) -> nil.
show_help(Parser) ->
    Settings = gleam@option:unwrap(
        erlang:element(5, Parser),
        glap@help_settings:default_help_settings()
    ),
    Printfun = case erlang:element(2, Settings) of
        true ->
            fun gleam_stdlib:print_error/1;

        false ->
            fun gleam_stdlib:print/1
    end,
    Tabdesc_length = glap@help_settings:get_tabdesc_string_length(
        erlang:element(2, Parser)
    )
    + 4,
    _pipe = glap@utils:strformat(
        <<"Usage: {} [OPTS...]\n{}\n\n"/utf8>>,
        [erlang:element(3, argv:load()), erlang:element(3, Parser)]
    ),
    Printfun(_pipe),
    show_help_aux(
        erlang:element(2, Parser),
        Settings,
        Printfun,
        Tabdesc_length,
        0
    ).

-file("src/glap/parser.gleam", 125).
-spec parse(parser(), list(binary())) -> {ok, list(glap@cliargs:c_l_i_arg())} |
    {error, glap@error:parsing_error()}.
parse(Parser, Args) ->
    Settings = gleam@option:unwrap(
        erlang:element(4, Parser),
        glap@parser_settings:default_parser_settings()
    ),
    Subcommands = gleam@list:filter(
        erlang:element(2, Parser),
        fun glap@arguments:is_command/1
    ),
    Subflags = gleam@list:filter(
        erlang:element(2, Parser),
        fun glap@arguments:is_flag/1
    ),
    Subunnamedarguments = gleam@list:filter(
        erlang:element(2, Parser),
        fun glap@arguments:is_unnamed_argument/1
    ),
    case {parse_aux(Args, Subcommands, Subflags, Subunnamedarguments, Settings),
        erlang:element(4, Settings)} of
        {{ok, X}, _} ->
            {ok, X};

        {{error, {E, Args@1}}, true} ->
            Showhelp_settings = gleam@option:unwrap(
                erlang:element(5, Parser),
                glap@help_settings:default_help_settings()
            ),
            Printfun = case erlang:element(2, Showhelp_settings) of
                true ->
                    fun gleam_stdlib:print_error/1;

                false ->
                    fun gleam_stdlib:print/1
            end,
            Tabdesc_length = glap@help_settings:get_tabdesc_string_length(
                erlang:element(2, Parser)
            )
            + 4,
            show_help_aux(
                Args@1,
                Showhelp_settings,
                Printfun,
                Tabdesc_length,
                0
            ),
            run_on_parse_error(Settings),
            {error, E};

        {{error, {E@1, _}}, false} ->
            run_on_parse_error(Settings),
            {error, E@1}
    end.

-file("src/glap/parser.gleam", 321).
-spec parse_argv(parser()) -> {ok, list(glap@cliargs:c_l_i_arg())} |
    {error, glap@error:parsing_error()}.
parse_argv(Parser) ->
    parse(Parser, erlang:element(4, argv:load())).