-module(eyg@parser@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/eyg/parser/parser.gleam").
-export([destructured/2, build_list/2, build_record/2, build_overwrite/2, do_patterns/2, expression/1, block/1]).
-export_type([reason/0, pattern/0]).

-type reason() :: unexpect_end |
    {unexpected_token, eyg@parser@token:token(), integer()} |
    {missing_equals, integer()} |
    {missing_arrow, integer()} |
    {unclosed_function_body, integer()} |
    {expected_effect_name, binary(), integer()} |
    {expected_builtin_name, integer()} |
    {invalid_cid_reference, integer()} |
    {invalid_release_version, integer()} |
    {invalid_import_path, integer()} |
    {trailing_tokens, eyg@parser@token:token(), integer()} |
    {invalid_character, binary(), integer()} |
    {unterminated_string_literal, integer()} |
    {invalid_escape_sequence, binary(), integer()}.

-type pattern() :: {assign, binary()} |
    {destructure,
        list({{binary(), {integer(), integer()}},
            gleam@option:option({{integer(), integer()},
                {binary(), {integer(), integer()}}})})}.

-file("src/eyg/parser/parser.gleam", 102).
-spec destructured(
    list({{binary(), {integer(), integer()}},
        gleam@option:option({{integer(), integer()},
            {binary(), {integer(), integer()}}})}),
    {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}}
) -> {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}}.
destructured(Matches, Term) ->
    gleam@list:fold(
        Matches,
        Term,
        fun(Acc, Pair) ->
            {Field, Assign} = Pair,
            {Field@1, Fspan} = Field,
            {Cspan@1, {Var@1, _}} = case Assign of
                {some, {Cspan, {Var, Vspan}}} ->
                    {Cspan, {Var, Vspan}};

                none ->
                    {Fspan, {Field@1, Fspan}}
            end,
            Aspan = {erlang:element(1, Fspan), erlang:element(2, Cspan@1)},
            Lspan = {erlang:element(1, Fspan),
                erlang:element(2, erlang:element(2, Term))},
            {{'let',
                    Var@1,
                    {{apply,
                            {{select, Field@1}, Fspan},
                            {{variable, <<"$"/utf8>>}, Cspan@1}},
                        Aspan},
                    Acc},
                Lspan}
        end
    ).

-file("src/eyg/parser/parser.gleam", 413).
-spec fail(list({eyg@parser@token:token(), integer()})) -> {ok, any()} |
    {error, reason()}.
fail(Tokens) ->
    case Tokens of
        [] ->
            {error, unexpect_end};

        [{T, Start} | _] ->
            {error, {unexpected_token, T, Start}}
    end.

-file("src/eyg/parser/parser.gleam", 51).
-spec do_destructure(
    list({eyg@parser@token:token(), integer()}),
    list({{binary(), {integer(), integer()}},
        gleam@option:option({{integer(), integer()},
            {binary(), {integer(), integer()}}})})
) -> {ok,
        {list({{binary(), {integer(), integer()}},
                gleam@option:option({{integer(), integer()},
                    {binary(), {integer(), integer()}}})}),
            list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
do_destructure(Tokens, Acc) ->
    case Tokens of
        [{right_brace, _} | Rest] ->
            {ok, {Acc, Rest}};

        [{{name, Field}, F}, {colon, C}, {{name, Var}, V} | Rest@1] ->
            Field@1 = {Field, {F, F + string:length(Field)}},
            Colon = {C, C + 1},
            Var@1 = {Var, {V, V + string:length(Var)}},
            Acc@1 = [{Field@1, {some, {Colon, Var@1}}} | Acc],
            case Rest@1 of
                [{right_brace, _} | Rest@2] ->
                    {ok, {Acc@1, Rest@2}};

                [{comma, _} | Rest@3] ->
                    do_destructure(Rest@3, Acc@1);

                _ ->
                    fail(Rest@1)
            end;

        [{{name, Field@2}, Start} | Rest@4] ->
            Field@3 = {Field@2, {Start, Start + string:length(Field@2)}},
            Acc@2 = [{Field@3, none} | Acc],
            case Rest@4 of
                [{right_brace, _} | Rest@5] ->
                    {ok, {Acc@2, Rest@5}};

                [{comma, _} | Rest@6] ->
                    do_destructure(Rest@6, Acc@2);

                _ ->
                    fail(Rest@4)
            end;

        _ ->
            fail(Tokens)
    end.

-file("src/eyg/parser/parser.gleam", 80).
-spec one_pattern(list({eyg@parser@token:token(), integer()})) -> {ok,
        {pattern(), list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
one_pattern(Tokens) ->
    case Tokens of
        [{{name, Label}, _} | Rest] ->
            {ok, {{assign, Label}, Rest}};

        [{left_brace, _} | Rest@1] ->
            gleam@result:'try'(
                do_destructure(Rest@1, []),
                fun(_use0) ->
                    {Matches, Rest@2} = _use0,
                    {ok, {{destructure, Matches}, Rest@2}}
                end
            );

        _ ->
            fail(Tokens)
    end.

-file("src/eyg/parser/parser.gleam", 420).
-spec next_pos(list({any(), FCS}), FCS) -> FCS.
next_pos(Rest, Fallback) ->
    case Rest of
        [{_, At} | _] ->
            At;

        [] ->
            Fallback
    end.

-file("src/eyg/parser/parser.gleam", 461).
-spec build_list(
    list({integer(),
        {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}}}),
    {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}}
) -> {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}}.
build_list(Reversed, Acc) ->
    case Reversed of
        [{From, Item} | Rest] ->
            {_, {_, C}} = Acc,
            {_, {_, B}} = Item,
            build_list(
                Rest,
                {{apply,
                        {{apply, {cons, {From, From + 1}}, Item}, {From, B}},
                        Acc},
                    {From, C}}
            );

        [] ->
            Acc
    end.

-file("src/eyg/parser/parser.gleam", 547).
-spec build_record(
    list({{FGV, FGW},
        binary(),
        {eyg@ir@tree:expression({FGV, FGW}), {FGV, FGW}}}),
    {eyg@ir@tree:expression({FGV, FGW}), {FGV, FGW}}
) -> {eyg@ir@tree:expression({FGV, FGW}), {FGV, FGW}}.
build_record(Reversed, Acc) ->
    case Reversed of
        [{Span, Label, Item} | Rest] ->
            {_, {_, C}} = Acc,
            {_, {_, B}} = Item,
            {A, _} = Span,
            build_record(
                Rest,
                {{apply, {{apply, {{extend, Label}, Span}, Item}, {A, B}}, Acc},
                    {A, C}}
            );

        [] ->
            Acc
    end.

-file("src/eyg/parser/parser.gleam", 566).
-spec build_overwrite(
    list({{FHN, FHO},
        binary(),
        {eyg@ir@tree:expression({FHN, FHO}), {FHN, FHO}}}),
    {eyg@ir@tree:expression({FHN, FHO}), {FHN, FHO}}
) -> {eyg@ir@tree:expression({FHN, FHO}), {FHN, FHO}}.
build_overwrite(Reversed, Acc) ->
    case Reversed of
        [{Span, Label, Item} | Rest] ->
            {_, {_, C}} = Acc,
            {_, {_, B}} = Item,
            {A, _} = Span,
            build_overwrite(
                Rest,
                {{apply,
                        {{apply, {{overwrite, Label}, Span}, Item}, {A, B}},
                        Acc},
                    {A, C}}
            );

        [] ->
            Acc
    end.

-file("src/eyg/parser/parser.gleam", 631).
-spec pop(list(FHZ)) -> {ok, {FHZ, list(FHZ)}} | {error, reason()}.
pop(Tokens) ->
    case Tokens of
        [T | Rest] ->
            {ok, {T, Rest}};

        [] ->
            {error, unexpect_end}
    end.

-file("src/eyg/parser/parser.gleam", 91).
-spec do_patterns(list({eyg@parser@token:token(), integer()}), list(pattern())) -> {ok,
        {list(pattern()), list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
do_patterns(Tokens, Acc) ->
    gleam@result:'try'(
        one_pattern(Tokens),
        fun(_use0) ->
            {Pattern, Tokens@1} = _use0,
            Acc@1 = [Pattern | Acc],
            gleam@result:'try'(
                pop(Tokens@1),
                fun(_use0@1) ->
                    {{Next, Start}, Rest} = _use0@1,
                    case Next of
                        comma ->
                            do_patterns(Rest, Acc@1);

                        right_paren ->
                            {ok, {Acc@1, Rest}};

                        _ ->
                            {error, {unexpected_token, Next, Start}}
                    end
                end
            )
        end
    ).

-file("src/eyg/parser/parser.gleam", 377).
-spec after_expression(
    {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}},
    list({eyg@parser@token:token(), integer()})
) -> {ok,
        {{eyg@ir@tree:expression({integer(), integer()}),
                {integer(), integer()}},
            list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
after_expression(Exp, Rest) ->
    case Rest of
        [{left_paren, _} | Rest@1] ->
            gleam@result:'try'(
                expression(Rest@1),
                fun(_use0) ->
                    {Arg, Rest@2} = _use0,
                    gleam@result:'try'(
                        do_args(Rest@2, [Arg]),
                        fun(_use0@1) ->
                            {Args, _, Rest@3} = _use0@1,
                            Args@1 = lists:reverse(Args),
                            Exp@1 = gleam@list:fold(
                                Args@1,
                                Exp,
                                fun(Acc, Arg@1) ->
                                    {_, {Start, _}} = Acc,
                                    {_, {_, End}} = Arg@1,
                                    {{apply, Acc, Arg@1}, {Start, End + 1}}
                                end
                            ),
                            after_expression(Exp@1, Rest@3)
                        end
                    )
                end
            );

        [{dot, Dot_at}, {{name, Label}, Name_at} | Rest@4] ->
            End@1 = Name_at + string:length(Label),
            Select = {{select, Label}, {Dot_at, End@1}},
            {_, {Start@1, _}} = Exp,
            Span = {Start@1, End@1},
            after_expression({{apply, Select, Exp}, Span}, Rest@4);

        _ ->
            {ok, {Exp, Rest}}
    end.

-file("src/eyg/parser/parser.gleam", 402).
-spec do_args(
    list({eyg@parser@token:token(), integer()}),
    list({eyg@ir@tree:expression({integer(), integer()}),
        {integer(), integer()}})
) -> {ok,
        {list({eyg@ir@tree:expression({integer(), integer()}),
                {integer(), integer()}}),
            integer(),
            list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
do_args(Tokens, Acc) ->
    case Tokens of
        [{right_paren, End} | Rest] ->
            {ok, {Acc, End + 1, Rest}};

        [{comma, _} | Rest@1] ->
            gleam@result:'try'(
                expression(Rest@1),
                fun(_use0) ->
                    {Arg, Rest@2} = _use0,
                    do_args(Rest@2, [Arg | Acc])
                end
            );

        _ ->
            fail(Tokens)
    end.

-file("src/eyg/parser/parser.gleam", 171).
-spec expression(list({eyg@parser@token:token(), integer()})) -> {ok,
        {{eyg@ir@tree:expression({integer(), integer()}),
                {integer(), integer()}},
            list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
expression(Tokens) ->
    gleam@result:'try'(
        pop(Tokens),
        fun(_use0) ->
            {{Token, Start}, Rest} = _use0,
            gleam@result:'try'(case Token of
                    {name, Label} ->
                        Span = {Start, Start + string:length(Label)},
                        {ok, {{{variable, Label}, Span}, Rest}};

                    'let' ->
                        gleam@result:'try'(
                            one_pattern(Rest),
                            fun(_use0@1) ->
                                {Pattern, Rest@1} = _use0@1,
                                gleam@result:'try'(case Rest@1 of
                                        [{equal, _} | Rest@2] ->
                                            {ok, Rest@2};

                                        [{_, At} | _] ->
                                            {error, {missing_equals, At}};

                                        [] ->
                                            {error, unexpect_end}
                                    end, fun(Rest@3) ->
                                        gleam@result:'try'(
                                            expression(Rest@3),
                                            fun(_use0@2) ->
                                                {Value, Rest@4} = _use0@2,
                                                gleam@result:'try'(
                                                    expression(Rest@4),
                                                    fun(_use0@3) ->
                                                        {Then, Rest@5} = _use0@3,
                                                        {_, {_, End}} = Then,
                                                        Span@1 = {Start, End},
                                                        Exp = case Pattern of
                                                            {assign, Label@1} ->
                                                                {{'let',
                                                                        Label@1,
                                                                        Value,
                                                                        Then},
                                                                    Span@1};

                                                            {destructure,
                                                                Matches} ->
                                                                {{'let',
                                                                        <<"$"/utf8>>,
                                                                        Value,
                                                                        destructured(
                                                                            Matches,
                                                                            Then
                                                                        )},
                                                                    Span@1}
                                                        end,
                                                        {ok, {Exp, Rest@5}}
                                                    end
                                                )
                                            end
                                        )
                                    end)
                            end
                        );

                    left_paren ->
                        gleam@result:'try'(
                            do_patterns(Rest, []),
                            fun(_use0@4) ->
                                {Patterns_reversed, Rest@6} = _use0@4,
                                gleam@result:'try'(case Rest@6 of
                                        [{right_arrow, _},
                                            {left_brace, Brace_at} |
                                            Rest@7] ->
                                            {ok, {Rest@7, Brace_at}};

                                        [{right_arrow, _}, {_, At@1} | _] ->
                                            {error, {missing_arrow, At@1}};

                                        [{right_arrow, Arrow_at}] ->
                                            {error,
                                                {missing_arrow, Arrow_at + 2}};

                                        [{_, At@2} | _] ->
                                            {error, {missing_arrow, At@2}};

                                        [] ->
                                            {error, unexpect_end}
                                    end, fun(_use0@5) ->
                                        {Rest@8, Brace_at@1} = _use0@5,
                                        gleam@result:'try'(
                                            expression(Rest@8),
                                            fun(_use0@6) ->
                                                {Body, Rest@9} = _use0@6,
                                                gleam@result:'try'(
                                                    case Rest@9 of
                                                        [{right_brace, End@1} |
                                                            Rest@10] ->
                                                            {ok,
                                                                {Rest@10, End@1}};

                                                        _ ->
                                                            {error,
                                                                {unclosed_function_body,
                                                                    Brace_at@1}}
                                                    end,
                                                    fun(_use0@7) ->
                                                        {Rest@11, End@2} = _use0@7,
                                                        Span@2 = {Start,
                                                            End@2 + 1},
                                                        Exp@1 = gleam@list:fold(
                                                            Patterns_reversed,
                                                            Body,
                                                            fun(
                                                                Body@1,
                                                                Pattern@1
                                                            ) ->
                                                                case Pattern@1 of
                                                                    {assign,
                                                                        Label@2} ->
                                                                        {{lambda,
                                                                                Label@2,
                                                                                Body@1},
                                                                            Span@2};

                                                                    {destructure,
                                                                        Matches@1} ->
                                                                        {{lambda,
                                                                                <<"$"/utf8>>,
                                                                                destructured(
                                                                                    Matches@1,
                                                                                    Body@1
                                                                                )},
                                                                            Span@2}
                                                                end
                                                            end
                                                        ),
                                                        {ok, {Exp@1, Rest@11}}
                                                    end
                                                )
                                            end
                                        )
                                    end)
                            end
                        );

                    {integer, Raw} ->
                        Value@2 = case gleam_stdlib:parse_int(Raw) of
                            {ok, Value@1} -> Value@1;
                            _assert_fail ->
                                erlang:error(#{gleam_error => let_assert,
                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                            file => <<?FILEPATH/utf8>>,
                                            module => <<"eyg/parser/parser"/utf8>>,
                                            function => <<"expression"/utf8>>,
                                            line => 230,
                                            value => _assert_fail,
                                            start => 7355,
                                            'end' => 7392,
                                            pattern_start => 7366,
                                            pattern_end => 7375})
                        end,
                        Span@3 = {Start, Start + string:length(Raw)},
                        {ok, {{{integer, Value@2}, Span@3}, Rest}};

                    minus ->
                        gleam@result:'try'(
                            pop(Rest),
                            fun(_use0@8) ->
                                {{Next, From}, Rest@12} = _use0@8,
                                case Next of
                                    {integer, Raw@1} ->
                                        Value@4 = case gleam_stdlib:parse_int(
                                            Raw@1
                                        ) of
                                            {ok, Value@3} -> Value@3;
                                            _assert_fail@1 ->
                                                erlang:error(
                                                        #{gleam_error => let_assert,
                                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                            file => <<?FILEPATH/utf8>>,
                                                            module => <<"eyg/parser/parser"/utf8>>,
                                                            function => <<"expression"/utf8>>,
                                                            line => 238,
                                                            value => _assert_fail@1,
                                                            start => 7623,
                                                            'end' => 7660,
                                                            pattern_start => 7634,
                                                            pattern_end => 7643}
                                                    )
                                        end,
                                        Span@4 = {Start,
                                            From + string:length(Raw@1)},
                                        {ok,
                                            {{{integer, -1 * Value@4}, Span@4},
                                                Rest@12}};

                                    _ ->
                                        {error,
                                            {unexpected_token, Token, Start}}
                                end
                            end
                        );

                    {string, Value@5} ->
                        Span@5 = {Start, (Start + string:length(Value@5)) + 2},
                        {ok, {{{string, Value@5}, Span@5}, Rest}};

                    left_square ->
                        do_list(Rest, Start, []);

                    left_brace ->
                        do_record(Rest, Start, []);

                    {uppername, Label@3} ->
                        Span@6 = {Start, Start + string:length(Label@3)},
                        {ok, {{{tag, Label@3}, Span@6}, Rest}};

                    match ->
                        case Rest of
                            [{left_brace, _} | Rest@13] ->
                                gleam@result:'try'(
                                    clauses(Rest@13, Start),
                                    fun(_use0@9) ->
                                        {Exp@2, _, Rest@14} = _use0@9,
                                        {ok, {Exp@2, Rest@14}}
                                    end
                                );

                            _ ->
                                gleam@result:'try'(
                                    expression(Rest),
                                    fun(_use0@10) ->
                                        {Subject, Rest@15} = _use0@10,
                                        case Rest@15 of
                                            [{left_brace, Inner} | Rest@16] ->
                                                gleam@result:'try'(
                                                    clauses(Rest@16, Inner),
                                                    fun(_use0@11) ->
                                                        {Exp@3, End@3, Rest@17} = _use0@11,
                                                        Span@7 = {Start, End@3},
                                                        {ok,
                                                            {{{apply,
                                                                        Exp@3,
                                                                        Subject},
                                                                    Span@7},
                                                                Rest@17}}
                                                    end
                                                );

                                            _ ->
                                                fail(Rest@15)
                                        end
                                    end
                                )
                        end;

                    perform ->
                        case Rest of
                            [{{uppername, Label@4}, End@4} | Rest@18] ->
                                Span@8 = {Start, End@4 + string:length(Label@4)},
                                {ok, {{{perform, Label@4}, Span@8}, Rest@18}};

                            _ ->
                                {error,
                                    {expected_effect_name,
                                        <<"perform"/utf8>>,
                                        next_pos(Rest, Start + 7)}}
                        end;

                    handle ->
                        case Rest of
                            [{{uppername, Label@5}, End@5} | Rest@19] ->
                                Span@9 = {Start, End@5 + string:length(Label@5)},
                                {ok, {{{handle, Label@5}, Span@9}, Rest@19}};

                            _ ->
                                {error,
                                    {expected_effect_name,
                                        <<"handle"/utf8>>,
                                        next_pos(Rest, Start + 6)}}
                        end;

                    bang ->
                        case Rest of
                            [{{name, Label@6}, End@6} | Rest@20] ->
                                Span@10 = {Start,
                                    End@6 + string:length(Label@6)},
                                {ok, {{{builtin, Label@6}, Span@10}, Rest@20}};

                            _ ->
                                {error,
                                    {expected_builtin_name,
                                        next_pos(Rest, Start + 1)}}
                        end;

                    hash ->
                        case Rest of
                            [{{name, Label@7}, End@7} | Rest@21] ->
                                Span@11 = {Start,
                                    End@7 + string:length(Label@7)},
                                case multiformats@cid@v1:from_string(Label@7) of
                                    {ok, {Cid, _}} ->
                                        {ok,
                                            {{{content_reference, Cid}, Span@11},
                                                Rest@21}};

                                    {error, _} ->
                                        {error, {invalid_cid_reference, End@7}}
                                end;

                            _ ->
                                {error,
                                    {invalid_cid_reference,
                                        next_pos(Rest, Start + 1)}}
                        end;

                    at ->
                        case Rest of
                            [{{name, Label@8}, End@8} | Rest@22] ->
                                After_name = End@8 + string:length(Label@8),
                                case Rest@22 of
                                    [{colon, _},
                                        {{integer, Raw@2}, Int_at} |
                                        Rest@23] ->
                                        Version@1 = case gleam_stdlib:parse_int(
                                            Raw@2
                                        ) of
                                            {ok, Version} -> Version;
                                            _assert_fail@2 ->
                                                erlang:error(
                                                        #{gleam_error => let_assert,
                                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                            file => <<?FILEPATH/utf8>>,
                                                            module => <<"eyg/parser/parser"/utf8>>,
                                                            function => <<"expression"/utf8>>,
                                                            line => 316,
                                                            value => _assert_fail@2,
                                                            start => 10241,
                                                            'end' => 10280,
                                                            pattern_start => 10252,
                                                            pattern_end => 10263}
                                                    )
                                        end,
                                        After_version = Int_at + string:length(
                                            Raw@2
                                        ),
                                        case Rest@23 of
                                            [{colon, _},
                                                {{name, Cid_label}, Cid_at} |
                                                Rest@24] ->
                                                After_cid = Cid_at + string:length(
                                                    Cid_label
                                                ),
                                                Span@12 = {Start, After_cid},
                                                case multiformats@cid@v1:from_string(
                                                    Cid_label
                                                ) of
                                                    {ok, {Cid@1, _}} ->
                                                        {ok,
                                                            {{{release_reference,
                                                                        Label@8,
                                                                        Version@1,
                                                                        Cid@1},
                                                                    Span@12},
                                                                Rest@24}};

                                                    {error, _} ->
                                                        {error,
                                                            {invalid_cid_reference,
                                                                Cid_at}}
                                                end;

                                            [{colon, Hash_at} | _] ->
                                                {error,
                                                    {invalid_cid_reference,
                                                        Hash_at + 1}};

                                            _ ->
                                                Span@13 = {Start, After_version},
                                                {ok,
                                                    {{{release_reference,
                                                                Label@8,
                                                                Version@1,
                                                                {cid,
                                                                    297,
                                                                    {multihash,
                                                                        sha256,
                                                                        <<143,
                                                                            171,
                                                                            132,
                                                                            193,
                                                                            178,
                                                                            239,
                                                                            11,
                                                                            237,
                                                                            187,
                                                                            22,
                                                                            81,
                                                                            164,
                                                                            153,
                                                                            54,
                                                                            34,
                                                                            109,
                                                                            16,
                                                                            139,
                                                                            216,
                                                                            209,
                                                                            66,
                                                                            180,
                                                                            135,
                                                                            86,
                                                                            79,
                                                                            251,
                                                                            7,
                                                                            31,
                                                                            89,
                                                                            235,
                                                                            100,
                                                                            152>>}}},
                                                            Span@13},
                                                        Rest@23}}
                                        end;

                                    [{colon, Colon_at} | _] ->
                                        {error,
                                            {invalid_release_version,
                                                Colon_at + 1}};

                                    _ ->
                                        Span@14 = {Start, After_name},
                                        {ok,
                                            {{{release_reference,
                                                        Label@8,
                                                        0,
                                                        {cid,
                                                            297,
                                                            {multihash,
                                                                sha256,
                                                                <<143,
                                                                    171,
                                                                    132,
                                                                    193,
                                                                    178,
                                                                    239,
                                                                    11,
                                                                    237,
                                                                    187,
                                                                    22,
                                                                    81,
                                                                    164,
                                                                    153,
                                                                    54,
                                                                    34,
                                                                    109,
                                                                    16,
                                                                    139,
                                                                    216,
                                                                    209,
                                                                    66,
                                                                    180,
                                                                    135,
                                                                    86,
                                                                    79,
                                                                    251,
                                                                    7,
                                                                    31,
                                                                    89,
                                                                    235,
                                                                    100,
                                                                    152>>}}},
                                                    Span@14},
                                                Rest@22}}
                                end;

                            _ ->
                                fail(Rest)
                        end;

                    import ->
                        case Rest of
                            [{{string, Value@6}, End@9} | Rest@25] ->
                                Span@15 = {Start,
                                    (End@9 + string:length(Value@6)) + 2},
                                {ok,
                                    {{{relative_reference, Value@6}, Span@15},
                                        Rest@25}};

                            _ ->
                                {error,
                                    {invalid_import_path,
                                        next_pos(Rest, Start + 6)}}
                        end;

                    {unexpected_grapheme, Raw@3} ->
                        {error,
                            {invalid_character,
                                gleam@string:slice(Raw@3, 0, 1),
                                Start}};

                    {unterminated_string, _} ->
                        {error, {unterminated_string_literal, Start}};

                    {invalid_escape, Raw@4} ->
                        {error,
                            {invalid_escape_sequence,
                                gleam@string:slice(Raw@4, 1, 1),
                                Start}};

                    _ ->
                        {error, {unexpected_token, Token, Start}}
                end, fun(_use0@12) ->
                    {Exp@4, Rest@26} = _use0@12,
                    after_expression(Exp@4, Rest@26)
                end)
        end
    ).

-file("src/eyg/parser/parser.gleam", 126).
-spec block(list({eyg@parser@token:token(), integer()})) -> {ok,
        {{eyg@ir@tree:expression({integer(), integer()}),
                {integer(), integer()}},
            list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
block(Tokens) ->
    gleam@result:'try'(
        pop(Tokens),
        fun(_use0) ->
            {{Token, Start}, Rest} = _use0,
            case Token of
                'let' ->
                    gleam@result:'try'(
                        one_pattern(Rest),
                        fun(_use0@1) ->
                            {Pattern, Rest@1} = _use0@1,
                            gleam@result:'try'(case Rest@1 of
                                    [{equal, _} | Rest@2] ->
                                        {ok, Rest@2};

                                    [{_, At} | _] ->
                                        {error, {missing_equals, At}};

                                    [] ->
                                        {error, unexpect_end}
                                end, fun(Rest@3) ->
                                    gleam@result:'try'(
                                        expression(Rest@3),
                                        fun(_use0@2) ->
                                            {Value, Rest@4} = _use0@2,
                                            case block(Rest@4) of
                                                {ok, {Then, Rest@5}} ->
                                                    {_, {_, End}} = Then,
                                                    Span = {Start, End},
                                                    Exp = case Pattern of
                                                        {assign, Label} ->
                                                            {{'let',
                                                                    Label,
                                                                    Value,
                                                                    Then},
                                                                Span};

                                                        {destructure, Matches} ->
                                                            {{'let',
                                                                    <<"$"/utf8>>,
                                                                    Value,
                                                                    destructured(
                                                                        Matches,
                                                                        Then
                                                                    )},
                                                                Span}
                                                    end,
                                                    {ok, {Exp, Rest@5}};

                                                {error, unexpect_end} ->
                                                    Span@1 = {Start, Start},
                                                    Then@1 = {vacant, {0, 0}},
                                                    Exp@1 = case Pattern of
                                                        {assign, Label@1} ->
                                                            {{'let',
                                                                    Label@1,
                                                                    Value,
                                                                    Then@1},
                                                                Span@1};

                                                        {destructure, Matches@1} ->
                                                            {{'let',
                                                                    <<"$"/utf8>>,
                                                                    Value,
                                                                    destructured(
                                                                        Matches@1,
                                                                        Then@1
                                                                    )},
                                                                Span@1}
                                                    end,
                                                    {ok, {Exp@1, Rest@4}};

                                                {error, Other} ->
                                                    {error, Other}
                                            end
                                        end
                                    )
                                end)
                        end
                    );

                _ ->
                    expression(Tokens)
            end
        end
    ).

-file("src/eyg/parser/parser.gleam", 428).
-spec do_list(
    list({eyg@parser@token:token(), integer()}),
    integer(),
    list({integer(),
        {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}}})
) -> {ok,
        {{eyg@ir@tree:expression({integer(), integer()}),
                {integer(), integer()}},
            list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
do_list(Tokens, Start, Acc) ->
    case Tokens of
        [] ->
            {error, unexpect_end};

        [{right_square, End} | Rest] ->
            Span = {Start, End + 1},
            {ok, {build_list(Acc, {tail, Span}), Rest}};

        _ ->
            gleam@result:'try'(
                expression(Tokens),
                fun(_use0) ->
                    {Item, Rest@1} = _use0,
                    Acc@1 = [{Start, Item} | Acc],
                    case Rest@1 of
                        [{comma, _}, {dot_dot, _} | Rest@2] ->
                            gleam@result:'try'(
                                expression(Rest@2),
                                fun(_use0@1) ->
                                    {Tail, Rest@3} = _use0@1,
                                    gleam@result:'try'(
                                        pop(Rest@3),
                                        fun(_use0@2) ->
                                            {{Token, Start@1}, Rest@4} = _use0@2,
                                            case Token of
                                                right_square ->
                                                    {ok,
                                                        {build_list(Acc@1, Tail),
                                                            Rest@4}};

                                                _ ->
                                                    {error,
                                                        {unexpected_token,
                                                            Token,
                                                            Start@1}}
                                            end
                                        end
                                    )
                                end
                            );

                        [{comma, Start@2} | Rest@5] ->
                            do_list(Rest@5, Start@2, Acc@1);

                        [{right_square, Start@3} | Rest@6] ->
                            Span@1 = {Start@3, Start@3 + 1},
                            {ok, {build_list(Acc@1, {tail, Span@1}), Rest@6}};

                        [{T, Start@4} | _] ->
                            {error, {unexpected_token, T, Start@4}};

                        [] ->
                            {error, unexpect_end}
                    end
                end
            )
    end.

-file("src/eyg/parser/parser.gleam", 482).
-spec do_record(
    list({eyg@parser@token:token(), integer()}),
    integer(),
    list({{integer(), integer()},
        binary(),
        {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}}})
) -> {ok,
        {{eyg@ir@tree:expression({integer(), integer()}),
                {integer(), integer()}},
            list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
do_record(Rest, Start, Acc) ->
    gleam@result:'try'(
        pop(Rest),
        fun(_use0) ->
            {{Token, Kstart}, Rest@1} = _use0,
            case Token of
                right_brace ->
                    {ok, {{empty, {Start, Kstart + 1}}, Rest@1}};

                {name, Label} ->
                    gleam@result:'try'(
                        pop(Rest@1),
                        fun(_use0@1) ->
                            {{Token@1, Next}, Rest@2} = _use0@1,
                            case Token@1 of
                                colon ->
                                    gleam@result:'try'(
                                        expression(Rest@2),
                                        fun(_use0@2) ->
                                            {Value, Rest@3} = _use0@2,
                                            Acc@1 = [{{Start, Next + 1},
                                                    Label,
                                                    Value} |
                                                Acc],
                                            case Rest@3 of
                                                [{comma, Start@1} | Rest@4] ->
                                                    do_record(
                                                        Rest@4,
                                                        Start@1,
                                                        Acc@1
                                                    );

                                                [{right_brace, Start@2} |
                                                    Rest@5] ->
                                                    Span = {Start@2,
                                                        Start@2 + 1},
                                                    {ok,
                                                        {build_record(
                                                                Acc@1,
                                                                {empty, Span}
                                                            ),
                                                            Rest@5}};

                                                _ ->
                                                    fail(Rest@3)
                                            end
                                        end
                                    );

                                comma ->
                                    Acc@2 = [{{Start,
                                                Kstart + string:length(Label)},
                                            Label,
                                            {{variable, Label},
                                                {Kstart,
                                                    Kstart + string:length(
                                                        Label
                                                    )}}} |
                                        Acc],
                                    do_record(Rest@2, Next, Acc@2);

                                right_brace ->
                                    Acc@3 = [{{Start,
                                                Kstart + string:length(Label)},
                                            Label,
                                            {{variable, Label},
                                                {Kstart,
                                                    Kstart + string:length(
                                                        Label
                                                    )}}} |
                                        Acc],
                                    Span@1 = {Next, Next + 1},
                                    {ok,
                                        {build_record(Acc@3, {empty, Span@1}),
                                            Rest@2}};

                                _ ->
                                    {error, {unexpected_token, Token@1, Start}}
                            end
                        end
                    );

                dot_dot ->
                    gleam@result:'try'(
                        expression(Rest@1),
                        fun(_use0@3) ->
                            {Value@1, Rest@6} = _use0@3,
                            gleam@result:'try'(
                                pop(Rest@6),
                                fun(_use0@4) ->
                                    {{Token@2, Start@3}, Rest@7} = _use0@4,
                                    gleam@result:'try'(case Token@2 of
                                            right_brace ->
                                                {ok, Rest@7};

                                            _ ->
                                                {error,
                                                    {unexpected_token,
                                                        Token@2,
                                                        Start@3}}
                                        end, fun(Rest@8) ->
                                            {ok,
                                                {build_overwrite(Acc, Value@1),
                                                    Rest@8}}
                                        end)
                                end
                            )
                        end
                    );

                _ ->
                    {error, {unexpected_token, Token, Start}}
            end
        end
    ).

-file("src/eyg/parser/parser.gleam", 603).
-spec do_clauses(
    list({eyg@parser@token:token(), integer()}),
    integer(),
    list({integer(),
        binary(),
        {integer(), integer()},
        {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}}})
) -> {ok,
        {list({integer(),
                binary(),
                {integer(), integer()},
                {eyg@ir@tree:expression({integer(), integer()}),
                    {integer(), integer()}}}),
            {eyg@ir@tree:expression({integer(), integer()}),
                {integer(), integer()}},
            list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
do_clauses(Tokens, Start, Acc) ->
    gleam@result:'try'(
        pop(Tokens),
        fun(_use0) ->
            {{Token, Clause}, Rest} = _use0,
            case Token of
                right_brace ->
                    {ok, {Acc, {no_cases, {Start, Clause + 1}}, Rest}};

                {uppername, Label} ->
                    gleam@result:'try'(
                        expression(Rest),
                        fun(_use0@1) ->
                            {Branch, Rest@1} = _use0@1,
                            Acc@1 = [{Start,
                                    Label,
                                    {Clause, Clause + string:length(Label)},
                                    Branch} |
                                Acc],
                            case Rest@1 of
                                [{_, Last} | _] ->
                                    do_clauses(Rest@1, Last, Acc@1);

                                [] ->
                                    {error, unexpect_end}
                            end
                        end
                    );

                bar ->
                    gleam@result:'try'(
                        expression(Rest),
                        fun(_use0@2) ->
                            {{Otherwise, Span}, Rest@2} = _use0@2,
                            case Rest@2 of
                                [{right_brace, _} | Rest@3] ->
                                    {ok, {Acc, {Otherwise, Span}, Rest@3}};

                                _ ->
                                    fail(Rest@2)
                            end
                        end
                    );

                _ ->
                    {error, {unexpected_token, Token, Clause}}
            end
        end
    ).

-file("src/eyg/parser/parser.gleam", 588).
-spec clauses(list({eyg@parser@token:token(), integer()}), integer()) -> {ok,
        {{eyg@ir@tree:expression({integer(), integer()}),
                {integer(), integer()}},
            integer(),
            list({eyg@parser@token:token(), integer()})}} |
    {error, reason()}.
clauses(Tokens, Start) ->
    gleam@result:'try'(
        do_clauses(Tokens, Start, []),
        fun(_use0) ->
            {Clauses, Tail, Rest} = _use0,
            {_, {_, End}} = Tail,
            Exp@1 = gleam@list:fold(
                Clauses,
                Tail,
                fun(Exp, Clause) ->
                    {Start@1, Label, Cspan, Branch} = Clause,
                    Case_ = {{'case', Label}, Cspan},
                    {_, {_, Branch_end}} = Branch,
                    Inner = {{apply, Case_, Branch},
                        {erlang:element(1, Cspan), Branch_end}},
                    {_, {_, Final}} = Tail,
                    {{apply, Inner, Exp}, {Start@1, Final}}
                end
            ),
            {ok, {Exp@1, End, Rest}}
        end
    ).