-module(gleam@http).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleam/http.gleam").
-export([parse_method/1, method_to_string/1, scheme_to_string/1, scheme_from_string/1, parse_content_disposition/1, parse_multipart_body/2, parse_multipart_headers/2]).
-export_type([method/0, scheme/0, multipart_headers/0, multipart_body/0, content_disposition/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Functions for working with HTTP data structures in Gleam.\n"
    "\n"
    " This module makes it easy to create and modify Requests and Responses, data types.\n"
    " A general HTTP message type is defined that enables functions to work on both requests and responses.\n"
    "\n"
    " This module does not implement a HTTP client or HTTP server, but it can be used as a base for them.\n"
).

-type method() :: get |
    post |
    head |
    put |
    delete |
    trace |
    connect |
    options |
    patch |
    {other, binary()}.

-type scheme() :: http | https.

-type multipart_headers() :: {multipart_headers,
        list({binary(), binary()}),
        bitstring()} |
    {more_required_for_headers,
        fun((bitstring()) -> {ok, multipart_headers()} | {error, nil})}.

-type multipart_body() :: {multipart_body, bitstring(), boolean(), bitstring()} |
    {more_required_for_body,
        bitstring(),
        fun((bitstring()) -> {ok, multipart_body()} | {error, nil})}.

-type content_disposition() :: {content_disposition,
        binary(),
        list({binary(), binary()})}.

-file("src/gleam/http.gleam", 75).
-spec is_valid_token_loop(binary()) -> boolean().
is_valid_token_loop(Token) ->
    case Token of
        <<""/utf8>> ->
            true;

        <<"!"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"#"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"$"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"%"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"&"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"'"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"*"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"+"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"-"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"."/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"^"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"_"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"`"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"|"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"~"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"0"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"1"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"2"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"3"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"4"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"5"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"6"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"7"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"8"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"9"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"A"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"B"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"C"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"D"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"E"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"F"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"G"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"H"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"I"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"J"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"K"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"L"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"M"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"N"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"O"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"P"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"Q"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"R"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"S"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"T"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"U"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"V"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"W"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"X"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"Y"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"Z"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"a"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"b"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"c"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"d"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"e"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"f"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"g"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"h"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"i"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"j"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"k"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"l"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"m"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"n"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"o"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"p"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"q"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"r"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"s"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"t"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"u"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"v"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"w"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"x"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"y"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        <<"z"/utf8, Rest/binary>> ->
            is_valid_token_loop(Rest);

        _ ->
            false
    end.

-file("src/gleam/http.gleam", 67).
-spec is_valid_token(binary()) -> boolean().
is_valid_token(Token) ->
    case Token of
        <<""/utf8>> ->
            false;

        _ ->
            is_valid_token_loop(Token)
    end.

-file("src/gleam/http.gleam", 31).
-spec parse_method(binary()) -> {ok, method()} | {error, nil}.
parse_method(Method) ->
    case Method of
        <<"CONNECT"/utf8>> ->
            {ok, connect};

        <<"DELETE"/utf8>> ->
            {ok, delete};

        <<"GET"/utf8>> ->
            {ok, get};

        <<"HEAD"/utf8>> ->
            {ok, head};

        <<"OPTIONS"/utf8>> ->
            {ok, options};

        <<"PATCH"/utf8>> ->
            {ok, patch};

        <<"POST"/utf8>> ->
            {ok, post};

        <<"PUT"/utf8>> ->
            {ok, put};

        <<"TRACE"/utf8>> ->
            {ok, trace};

        Method@1 ->
            case is_valid_token(Method@1) of
                true ->
                    {ok, {other, Method@1}};

                false ->
                    {error, nil}
            end
    end.

-file("src/gleam/http.gleam", 162).
-spec method_to_string(method()) -> binary().
method_to_string(Method) ->
    case Method of
        connect ->
            <<"CONNECT"/utf8>>;

        delete ->
            <<"DELETE"/utf8>>;

        get ->
            <<"GET"/utf8>>;

        head ->
            <<"HEAD"/utf8>>;

        options ->
            <<"OPTIONS"/utf8>>;

        patch ->
            <<"PATCH"/utf8>>;

        post ->
            <<"POST"/utf8>>;

        put ->
            <<"PUT"/utf8>>;

        trace ->
            <<"TRACE"/utf8>>;

        {other, Method@1} ->
            Method@1
    end.

-file("src/gleam/http.gleam", 193).
?DOC(
    " Convert a scheme into a string.\n"
    "\n"
    " # Examples\n"
    "\n"
    " ```gleam\n"
    " assert \"http\" == scheme_to_string(Http)\n"
    " assert \"https\" == scheme_to_string(Https)\n"
    " ```\n"
).
-spec scheme_to_string(scheme()) -> binary().
scheme_to_string(Scheme) ->
    case Scheme of
        http ->
            <<"http"/utf8>>;

        https ->
            <<"https"/utf8>>
    end.

-file("src/gleam/http.gleam", 209).
?DOC(
    " Parse a HTTP scheme from a string\n"
    "\n"
    " # Examples\n"
    "\n"
    " ```gleam\n"
    " assert Ok(Http) == scheme_from_string(\"http\")\n"
    " assert Error(Nil) == scheme_from_string(\"ftp\")\n"
    " ```\n"
).
-spec scheme_from_string(binary()) -> {ok, scheme()} | {error, nil}.
scheme_from_string(Scheme) ->
    case string:lowercase(Scheme) of
        <<"http"/utf8>> ->
            {ok, http};

        <<"https"/utf8>> ->
            {ok, https};

        _ ->
            {error, nil}
    end.

-file("src/gleam/http.gleam", 441).
-spec skip_whitespace(bitstring()) -> bitstring().
skip_whitespace(Data) ->
    case Data of
        <<32, Data@1/binary>> ->
            skip_whitespace(Data@1);

        <<9, Data@1/binary>> ->
            skip_whitespace(Data@1);

        _ ->
            Data
    end.

-file("src/gleam/http.gleam", 531).
-spec more_please_headers(
    fun((bitstring()) -> {ok, multipart_headers()} | {error, nil}),
    bitstring()
) -> {ok, multipart_headers()} | {error, nil}.
more_please_headers(Continuation, Existing) ->
    {ok,
        {more_required_for_headers,
            fun(More) ->
                gleam@bool:guard(
                    More =:= <<>>,
                    {error, nil},
                    fun() ->
                        Continuation(<<Existing/bitstring, More/bitstring>>)
                    end
                )
            end}}.

-file("src/gleam/http.gleam", 612).
-spec parse_rfc_2045_parameter_quoted_value(binary(), binary(), binary()) -> {ok,
        {{binary(), binary()}, binary()}} |
    {error, nil}.
parse_rfc_2045_parameter_quoted_value(Header, Name, Value) ->
    case gleam_stdlib:string_pop_grapheme(Header) of
        {error, nil} ->
            {error, nil};

        {ok, {<<"\""/utf8>>, Rest}} ->
            {ok, {{Name, Value}, Rest}};

        {ok, {<<"\\"/utf8>>, Rest@1}} ->
            case gleam_stdlib:string_pop_grapheme(Rest@1) of
                {ok, X} ->
                    {Grapheme, Rest@2} = X,
                    parse_rfc_2045_parameter_quoted_value(
                        Rest@2,
                        Name,
                        <<Value/binary, Grapheme/binary>>
                    );

                {error, E} ->
                    {error, E}
            end;

        {ok, {Grapheme@1, Rest@3}} ->
            parse_rfc_2045_parameter_quoted_value(
                Rest@3,
                Name,
                <<Value/binary, Grapheme@1/binary>>
            )
    end.

-file("src/gleam/http.gleam", 629).
-spec parse_rfc_2045_parameter_unquoted_value(binary(), binary(), binary()) -> {{binary(),
        binary()},
    binary()}.
parse_rfc_2045_parameter_unquoted_value(Header, Name, Value) ->
    case gleam_stdlib:string_pop_grapheme(Header) of
        {error, nil} ->
            {{Name, Value}, Header};

        {ok, {<<";"/utf8>>, Rest}} ->
            {{Name, Value}, Rest};

        {ok, {<<" "/utf8>>, Rest}} ->
            {{Name, Value}, Rest};

        {ok, {<<"\t"/utf8>>, Rest}} ->
            {{Name, Value}, Rest};

        {ok, {Grapheme, Rest@1}} ->
            parse_rfc_2045_parameter_unquoted_value(
                Rest@1,
                Name,
                <<Value/binary, Grapheme/binary>>
            )
    end.

-file("src/gleam/http.gleam", 600).
-spec parse_rfc_2045_parameter_value(binary(), binary()) -> {ok,
        {{binary(), binary()}, binary()}} |
    {error, nil}.
parse_rfc_2045_parameter_value(Header, Name) ->
    case gleam_stdlib:string_pop_grapheme(Header) of
        {error, nil} ->
            {error, nil};

        {ok, {<<"\""/utf8>>, Rest}} ->
            parse_rfc_2045_parameter_quoted_value(Rest, Name, <<""/utf8>>);

        {ok, {Grapheme, Rest@1}} ->
            {ok,
                parse_rfc_2045_parameter_unquoted_value(Rest@1, Name, Grapheme)}
    end.

-file("src/gleam/http.gleam", 589).
-spec parse_rfc_2045_parameter(binary(), binary()) -> {ok,
        {{binary(), binary()}, binary()}} |
    {error, nil}.
parse_rfc_2045_parameter(Header, Name) ->
    case gleam_stdlib:string_pop_grapheme(Header) of
        {ok, X} ->
            {Grapheme, Rest} = X,
            case Grapheme of
                <<"="/utf8>> ->
                    parse_rfc_2045_parameter_value(Rest, Name);

                _ ->
                    parse_rfc_2045_parameter(
                        Rest,
                        <<Name/binary, (string:lowercase(Grapheme))/binary>>
                    )
            end;

        {error, E} ->
            {error, E}
    end.

-file("src/gleam/http.gleam", 571).
-spec parse_rfc_2045_parameters(binary(), list({binary(), binary()})) -> {ok,
        list({binary(), binary()})} |
    {error, nil}.
parse_rfc_2045_parameters(Header, Parameters) ->
    case gleam_stdlib:string_pop_grapheme(Header) of
        {error, nil} ->
            {ok, lists:reverse(Parameters)};

        {ok, {<<";"/utf8>>, Rest}} ->
            parse_rfc_2045_parameters(Rest, Parameters);

        {ok, {<<" "/utf8>>, Rest}} ->
            parse_rfc_2045_parameters(Rest, Parameters);

        {ok, {<<"\t"/utf8>>, Rest}} ->
            parse_rfc_2045_parameters(Rest, Parameters);

        {ok, {Grapheme, Rest@1}} ->
            Acc = string:lowercase(Grapheme),
            begin
                Result = parse_rfc_2045_parameter(Rest@1, Acc),
                case Result of
                    {ok, X} ->
                        {Parameter, Rest@2} = X,
                        parse_rfc_2045_parameters(
                            Rest@2,
                            [Parameter | Parameters]
                        );

                    {error, E} ->
                        {error, E}
                end
            end
    end.

-file("src/gleam/http.gleam", 553).
-spec parse_content_disposition_type(binary(), binary()) -> {ok,
        content_disposition()} |
    {error, nil}.
parse_content_disposition_type(Header, Name) ->
    case gleam_stdlib:string_pop_grapheme(Header) of
        {error, nil} ->
            {ok, {content_disposition, Name, []}};

        {ok, {<<" "/utf8>>, Rest}} ->
            Result = parse_rfc_2045_parameters(Rest, []),
            case Result of
                {ok, X} ->
                    {ok, {content_disposition, Name, X}};

                {error, E} ->
                    {error, E}
            end;

        {ok, {<<"\t"/utf8>>, Rest}} ->
            Result = parse_rfc_2045_parameters(Rest, []),
            case Result of
                {ok, X} ->
                    {ok, {content_disposition, Name, X}};

                {error, E} ->
                    {error, E}
            end;

        {ok, {<<";"/utf8>>, Rest}} ->
            Result = parse_rfc_2045_parameters(Rest, []),
            case Result of
                {ok, X} ->
                    {ok, {content_disposition, Name, X}};

                {error, E} ->
                    {error, E}
            end;

        {ok, {Grapheme, Rest@1}} ->
            parse_content_disposition_type(
                Rest@1,
                <<Name/binary, (string:lowercase(Grapheme))/binary>>
            )
    end.

-file("src/gleam/http.gleam", 547).
-spec parse_content_disposition(binary()) -> {ok, content_disposition()} |
    {error, nil}.
parse_content_disposition(Header) ->
    parse_content_disposition_type(Header, <<""/utf8>>).

-file("src/gleam/http.gleam", 647).
-spec more_please_body(
    fun((bitstring()) -> {ok, multipart_body()} | {error, nil}),
    bitstring(),
    bitstring()
) -> {ok, multipart_body()} | {error, nil}.
more_please_body(Continuation, Chunk, Existing) ->
    _pipe = fun(More) ->
        gleam@bool:guard(
            More =:= <<>>,
            {error, nil},
            fun() -> Continuation(<<Existing/bitstring, More/bitstring>>) end
        )
    end,
    _pipe@1 = {more_required_for_body, Chunk, _pipe},
    {ok, _pipe@1}.

-file("src/gleam/http.gleam", 320).
-spec parse_body_loop(bitstring(), bitstring(), bitstring()) -> {ok,
        multipart_body()} |
    {error, nil}.
parse_body_loop(Data, Boundary, Body) ->
    Dsize = erlang:byte_size(Data),
    Bsize = erlang:byte_size(Boundary),
    Required = 6 + Bsize,
    case Data of
        _ when Dsize < Required ->
            more_please_body(
                fun(_capture) -> parse_body_loop(_capture, Boundary, <<>>) end,
                Body,
                Data
            );

        <<13, 10, Data@1/binary>> ->
            Desired = <<45, 45, Boundary/bitstring>>,
            Size = erlang:byte_size(Desired),
            Dsize@1 = erlang:byte_size(Data@1),
            Prefix = gleam_stdlib:bit_array_slice(Data@1, 0, Size),
            Rest = gleam_stdlib:bit_array_slice(Data@1, Size, Dsize@1 - Size),
            case {Prefix =:= {ok, Desired}, Rest} of
                {true, {ok, <<13, 10, _/binary>>}} ->
                    {ok, {multipart_body, Body, false, Data@1}};

                {true, {ok, <<45, 45, Data@2/binary>>}} ->
                    {ok, {multipart_body, Body, true, Data@2}};

                {false, _} ->
                    parse_body_loop(
                        Data@1,
                        Boundary,
                        <<Body/bitstring, 13, 10>>
                    );

                {_, _} ->
                    {error, nil}
            end;

        <<Char, Data@3/binary>> ->
            parse_body_loop(Data@3, Boundary, <<Body/bitstring, Char>>);

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => <<"unreachable"/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"gleam/http"/utf8>>,
                    function => <<"parse_body_loop"/utf8>>,
                    line => 361})
    end.

-file("src/gleam/http.gleam", 308).
-spec parse_body_with_bit_array(bitstring(), bitstring()) -> {ok,
        multipart_body()} |
    {error, nil}.
parse_body_with_bit_array(Data, Boundary) ->
    Bsize = erlang:byte_size(Boundary),
    Prefix = gleam_stdlib:bit_array_slice(Data, 0, 2 + Bsize),
    case Prefix =:= {ok, <<45, 45, Boundary/bitstring>>} of
        true ->
            {ok, {multipart_body, <<>>, false, Data}};

        false ->
            parse_body_loop(Data, Boundary, <<>>)
    end.

-file("src/gleam/http.gleam", 299).
?DOC(
    " Parse the body for part of a multipart message, as defined in RFC 2045. The\n"
    " body is everything until the next boundary. This function is generally to be\n"
    " called after calling `parse_multipart_headers` for a given part.\n"
    "\n"
    " This function will accept input of any size, it is up to the caller to limit\n"
    " it if needed.\n"
    "\n"
    " To enable streaming parsing of multipart messages, this function will return\n"
    " a continuation if there is not enough data to fully parse the body, along\n"
    " with the data that has been parsed so far. Further information is available\n"
    " in the documentation for `MultipartBody`.\n"
).
-spec parse_multipart_body(bitstring(), binary()) -> {ok, multipart_body()} |
    {error, nil}.
parse_multipart_body(Data, Boundary) ->
    _pipe = Boundary,
    _pipe@1 = gleam_stdlib:identity(_pipe),
    parse_body_with_bit_array(Data, _pipe@1).

-file("src/gleam/http.gleam", 484).
-spec parse_header_value(
    bitstring(),
    list({binary(), binary()}),
    bitstring(),
    bitstring()
) -> {ok, multipart_headers()} | {error, nil}.
parse_header_value(Data, Headers, Name, Value) ->
    Size = erlang:byte_size(Data),
    case Data of
        _ when Size < 4 ->
            _pipe@2 = fun(Data@1) -> _pipe = Data@1,
                _pipe@1 = skip_whitespace(_pipe),
                parse_header_value(_pipe@1, Headers, Name, Value) end,
            more_please_headers(_pipe@2, Data);

        <<13, 10, 13, 10, Data@2/binary>> ->
            case gleam@bit_array:to_string(Name) of
                {ok, X} ->
                    Name@1 = X,
                    case gleam@bit_array:to_string(Value) of
                        {ok, X@1} ->
                            {ok,
                                begin
                                    Headers@1 = lists:reverse(
                                        [{string:lowercase(Name@1), X@1} |
                                            Headers]
                                    ),
                                    {multipart_headers, Headers@1, Data@2}
                                end};

                        {error, E} ->
                            {error, E}
                    end;

                {error, E@1} ->
                    {error, E@1}
            end;

        <<13, 10, 32, Data@3/binary>> ->
            parse_header_value(Data@3, Headers, Name, Value);

        <<13, 10, 9, Data@3/binary>> ->
            parse_header_value(Data@3, Headers, Name, Value);

        <<13, 10, Data@4/binary>> ->
            case gleam@bit_array:to_string(Name) of
                {ok, X@2} ->
                    Name@2 = X@2,
                    case gleam@bit_array:to_string(Value) of
                        {ok, X@3} ->
                            Headers@2 = [{string:lowercase(Name@2), X@3} |
                                Headers],
                            parse_header_name(Data@4, Headers@2, <<>>);

                        {error, E@2} ->
                            {error, E@2}
                    end;

                {error, E@3} ->
                    {error, E@3}
            end;

        <<Char, Rest/binary>> ->
            Value@1 = <<Value/bitstring, Char>>,
            parse_header_value(Rest, Headers, Name, Value@1);

        _ ->
            {error, nil}
    end.

-file("src/gleam/http.gleam", 465).
-spec parse_header_name(bitstring(), list({binary(), binary()}), bitstring()) -> {ok,
        multipart_headers()} |
    {error, nil}.
parse_header_name(Data, Headers, Name) ->
    case skip_whitespace(Data) of
        <<58, Data@1/binary>> ->
            _pipe = Data@1,
            _pipe@1 = skip_whitespace(_pipe),
            parse_header_value(_pipe@1, Headers, Name, <<>>);

        <<Char, Data@2/binary>> ->
            parse_header_name(Data@2, Headers, <<Name/bitstring, Char>>);

        _ ->
            more_please_headers(
                fun(_capture) -> parse_header_name(_capture, Headers, Name) end,
                Data
            )
    end.

-file("src/gleam/http.gleam", 449).
-spec do_parse_headers(bitstring()) -> {ok, multipart_headers()} | {error, nil}.
do_parse_headers(Data) ->
    case Data of
        <<13, 10, 13, 10, Data@1/binary>> ->
            {ok, {multipart_headers, [], Data@1}};

        <<13, 10, Data@2/binary>> ->
            parse_header_name(Data@2, [], <<>>);

        <<13>> ->
            more_please_headers(fun do_parse_headers/1, Data);

        <<>> ->
            more_please_headers(fun do_parse_headers/1, Data);

        _ ->
            {error, nil}
    end.

-file("src/gleam/http.gleam", 365).
-spec parse_headers_after_prelude(bitstring(), bitstring()) -> {ok,
        multipart_headers()} |
    {error, nil}.
parse_headers_after_prelude(Data, Boundary) ->
    Dsize = erlang:byte_size(Data),
    Bsize = erlang:byte_size(Boundary),
    Required_size = Bsize + 4,
    case Dsize < Required_size of
        true ->
            more_please_headers(
                fun(_capture) ->
                    parse_headers_after_prelude(_capture, Boundary)
                end,
                Data
            );

        false ->
            case gleam_stdlib:bit_array_slice(Data, 0, Required_size - 2) of
                {ok, X} ->
                    Prefix = X,
                    case gleam_stdlib:bit_array_slice(Data, 2 + Bsize, 2) of
                        {ok, X@1} ->
                            Second = X@1,
                            Desired = <<45, 45, Boundary/bitstring>>,
                            case Prefix /= Desired of
                                true ->
                                    {error, nil};

                                false ->
                                    case Second =:= <<45, 45>> of
                                        true ->
                                            Rest_size = Dsize - Required_size,
                                            case gleam_stdlib:bit_array_slice(
                                                Data,
                                                Required_size,
                                                Rest_size
                                            ) of
                                                {ok, X@2} ->
                                                    {ok,
                                                        {multipart_headers,
                                                            [],
                                                            X@2}};

                                                {error, E} ->
                                                    {error, E}
                                            end;

                                        false ->
                                            Start = Required_size - 2,
                                            Rest_size@1 = (Dsize - Required_size)
                                            + 2,
                                            case gleam_stdlib:bit_array_slice(
                                                Data,
                                                Start,
                                                Rest_size@1
                                            ) of
                                                {ok, X@3} ->
                                                    do_parse_headers(X@3);

                                                {error, E@1} ->
                                                    {error, E@1}
                                            end
                                    end
                            end;

                        {error, E@2} ->
                            {error, E@2}
                    end;

                {error, E@3} ->
                    {error, E@3}
            end
    end.

-file("src/gleam/http.gleam", 407).
-spec skip_preamble(bitstring(), bitstring()) -> {ok, multipart_headers()} |
    {error, nil}.
skip_preamble(Data, Boundary) ->
    Data_size = erlang:byte_size(Data),
    Boundary_size = erlang:byte_size(Boundary),
    Required = Boundary_size + 4,
    case Data of
        _ when Data_size < Required ->
            more_please_headers(
                fun(_capture) -> skip_preamble(_capture, Boundary) end,
                Data
            );

        <<13, 10, 45, 45, Data@1/binary>> ->
            case gleam_stdlib:bit_array_slice(Data@1, 0, Boundary_size) of
                {ok, Prefix} when Prefix =:= Boundary ->
                    Start = Boundary_size,
                    Length = erlang:byte_size(Data@1) - Boundary_size,
                    case gleam_stdlib:bit_array_slice(Data@1, Start, Length) of
                        {ok, X} ->
                            do_parse_headers(X);

                        {error, E} ->
                            {error, E}
                    end;

                {ok, _} ->
                    skip_preamble(Data@1, Boundary);

                {error, _} ->
                    {error, nil}
            end;

        <<_, Data@2/binary>> ->
            skip_preamble(Data@2, Boundary);

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => <<"unreachable"/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"gleam/http"/utf8>>,
                    function => <<"skip_preamble"/utf8>>,
                    line => 437})
    end.

-file("src/gleam/http.gleam", 271).
?DOC(
    " Parse the headers for part of a multipart message, as defined in RFC 2045.\n"
    "\n"
    " This function skips any preamble before the boundary. The preamble may be\n"
    " retrieved using `parse_multipart_body`.\n"
    "\n"
    " This function will accept input of any size, it is up to the caller to limit\n"
    " it if needed.\n"
    "\n"
    " To enable streaming parsing of multipart messages, this function will return\n"
    " a continuation if there is not enough data to fully parse the headers.\n"
    " Further information is available in the documentation for `MultipartBody`.\n"
).
-spec parse_multipart_headers(bitstring(), binary()) -> {ok,
        multipart_headers()} |
    {error, nil}.
parse_multipart_headers(Data, Boundary) ->
    Boundary@1 = gleam_stdlib:identity(Boundary),
    Prefix = <<45, 45, Boundary@1/bitstring>>,
    case gleam_stdlib:bit_array_slice(Data, 0, erlang:byte_size(Prefix)) =:= {ok,
        Prefix} of
        true ->
            parse_headers_after_prelude(Data, Boundary@1);

        false ->
            skip_preamble(Data, Boundary@1)
    end.