-module(taffy@parser@flow).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/taffy/parser/flow.gleam").
-export([parse_flow_value/1, parse_flow_mapping/1, parse_flow_key_with_colon/1, parse_flow_sequence/1]).

-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(false).

-file("src/taffy/parser/flow.gleam", 166).
?DOC(false).
-spec check_adjacent_colon(
    taffy@value:yaml_value(),
    binary(),
    taffy@parser@types:parser()
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
check_adjacent_colon(Key_val, Plain, Parser) ->
    case gleam_stdlib:string_starts_with(Plain, <<":"/utf8>>) of
        true ->
            Key = taffy@parser@scalar:value_to_key_string(Key_val),
            Rest = gleam@string:drop_start(Plain, 1),
            Val = case Rest of
                <<""/utf8>> ->
                    null;

                _ ->
                    taffy@parser@scalar:parse_scalar(Rest)
            end,
            {ok,
                {{mapping, [{Key, Val}]}, taffy@parser@helpers:advance(Parser)}};

        false ->
            {ok, {Key_val, Parser}}
    end.

-file("src/taffy/parser/flow.gleam", 429).
?DOC(false).
-spec parse_flow_collection_key(
    taffy@parser@types:parser(),
    fun((taffy@parser@types:parser()) -> {ok,
            {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
        {error, taffy@parser@types:parse_error()})
) -> {ok, {binary(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_collection_key(Parser, Parse_fn) ->
    gleam@result:'try'(
        Parse_fn(taffy@parser@helpers:advance(Parser)),
        fun(_use0) ->
            {Val, Parser@1} = _use0,
            {ok, {taffy@parser@scalar:value_to_key_string(Val), Parser@1}}
        end
    ).

-file("src/taffy/parser/flow.gleam", 460).
?DOC(false).
-spec parse_alias_flow_key(taffy@parser@types:parser(), binary()) -> {ok,
        {binary(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_alias_flow_key(Parser, Name) ->
    Parser@1 = taffy@parser@helpers:advance(Parser),
    case taffy@parser@types:resolve_alias(Parser@1, Name) of
        {ok, {Val, Parser@2}} ->
            {ok, {taffy@parser@scalar:value_to_key_string(Val), Parser@2}};

        {error, <<"budget exceeded"/utf8>>} ->
            {error,
                {parse_error,
                    <<"Alias expansion budget exceeded (possible alias-bomb)"/utf8>>,
                    erlang:element(4, Parser@1)}};

        {error, _} ->
            {error,
                {parse_error,
                    <<"Unknown anchor: "/utf8, Name/binary>>,
                    erlang:element(4, Parser@1)}}
    end.

-file("src/taffy/parser/flow.gleam", 489).
?DOC(false).
-spec collect_flow_key_parts(taffy@parser@types:parser(), binary()) -> {ok,
        {binary(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
collect_flow_key_parts(Parser, Acc) ->
    case taffy@parser@helpers:current(Parser) of
        {some, colon} ->
            After_colon = taffy@parser@helpers:advance(Parser),
            case taffy@parser@helpers:current(After_colon) of
                {some, {indent, _}} ->
                    {ok, {gleam@string:trim_end(Acc), Parser}};

                {some, {plain, _}} ->
                    {ok, {gleam@string:trim_end(Acc), Parser}};

                {some, {single_quoted, _}} ->
                    {ok, {gleam@string:trim_end(Acc), Parser}};

                {some, {double_quoted, _}} ->
                    {ok, {gleam@string:trim_end(Acc), Parser}};

                {some, bracket_open} ->
                    {ok, {gleam@string:trim_end(Acc), Parser}};

                {some, brace_open} ->
                    {ok, {gleam@string:trim_end(Acc), Parser}};

                _ ->
                    {ok, {gleam@string:trim_end(Acc), Parser}}
            end;

        {some, {plain, S}} ->
            Parser@1 = taffy@parser@helpers:advance(Parser),
            collect_flow_key_parts(Parser@1, <<Acc/binary, S/binary>>);

        {some, {indent, _}} ->
            case taffy@parser@helpers:skip_flow_whitespace(Parser) of
                {error, _} ->
                    {ok, {gleam@string:trim_end(Acc), Parser}};

                {ok, Parser_after_ws} ->
                    case taffy@parser@helpers:current(Parser_after_ws) of
                        {some, {plain, S@1}} ->
                            Parser@2 = taffy@parser@helpers:advance(
                                Parser_after_ws
                            ),
                            collect_flow_key_parts(
                                Parser@2,
                                <<<<Acc/binary, " "/utf8>>/binary, S@1/binary>>
                            );

                        _ ->
                            {ok, {gleam@string:trim_end(Acc), Parser}}
                    end
            end;

        {some, newline} ->
            case taffy@parser@helpers:skip_flow_whitespace(Parser) of
                {error, _} ->
                    {ok, {gleam@string:trim_end(Acc), Parser}};

                {ok, Parser_after_ws} ->
                    case taffy@parser@helpers:current(Parser_after_ws) of
                        {some, {plain, S@1}} ->
                            Parser@2 = taffy@parser@helpers:advance(
                                Parser_after_ws
                            ),
                            collect_flow_key_parts(
                                Parser@2,
                                <<<<Acc/binary, " "/utf8>>/binary, S@1/binary>>
                            );

                        _ ->
                            {ok, {gleam@string:trim_end(Acc), Parser}}
                    end
            end;

        _ ->
            {ok, {gleam@string:trim_end(Acc), Parser}}
    end.

-file("src/taffy/parser/flow.gleam", 531).
?DOC(false).
-spec collect_flow_plain_scalar_parts(taffy@parser@types:parser(), binary()) -> {binary(),
    taffy@parser@types:parser()}.
collect_flow_plain_scalar_parts(Parser, Acc) ->
    case taffy@parser@helpers:current(Parser) of
        {some, comma} ->
            {gleam@string:trim_end(Acc), Parser};

        {some, bracket_close} ->
            {gleam@string:trim_end(Acc), Parser};

        {some, brace_close} ->
            {gleam@string:trim_end(Acc), Parser};

        {some, colon} ->
            {gleam@string:trim_end(Acc), Parser};

        {some, {plain, S}} ->
            Parser@1 = taffy@parser@helpers:advance(Parser),
            collect_flow_plain_scalar_parts(Parser@1, <<Acc/binary, S/binary>>);

        {some, {indent, _}} ->
            case taffy@parser@helpers:flow_whitespace_has_comment(Parser) of
                true ->
                    {gleam@string:trim_end(Acc), Parser};

                false ->
                    case taffy@parser@helpers:skip_flow_whitespace(Parser) of
                        {error, _} ->
                            {gleam@string:trim_end(Acc), Parser};

                        {ok, Parser_after_ws} ->
                            case taffy@parser@helpers:current(Parser_after_ws) of
                                {some, {plain, S@1}} ->
                                    Parser@2 = taffy@parser@helpers:advance(
                                        Parser_after_ws
                                    ),
                                    collect_flow_plain_scalar_parts(
                                        Parser@2,
                                        <<<<Acc/binary, " "/utf8>>/binary,
                                            S@1/binary>>
                                    );

                                _ ->
                                    {gleam@string:trim_end(Acc), Parser}
                            end
                    end
            end;

        {some, newline} ->
            case taffy@parser@helpers:flow_whitespace_has_comment(Parser) of
                true ->
                    {gleam@string:trim_end(Acc), Parser};

                false ->
                    case taffy@parser@helpers:skip_flow_whitespace(Parser) of
                        {error, _} ->
                            {gleam@string:trim_end(Acc), Parser};

                        {ok, Parser_after_ws} ->
                            case taffy@parser@helpers:current(Parser_after_ws) of
                                {some, {plain, S@1}} ->
                                    Parser@2 = taffy@parser@helpers:advance(
                                        Parser_after_ws
                                    ),
                                    collect_flow_plain_scalar_parts(
                                        Parser@2,
                                        <<<<Acc/binary, " "/utf8>>/binary,
                                            S@1/binary>>
                                    );

                                _ ->
                                    {gleam@string:trim_end(Acc), Parser}
                            end
                    end
            end;

        _ ->
            {gleam@string:trim_end(Acc), Parser}
    end.

-file("src/taffy/parser/flow.gleam", 75).
?DOC(false).
-spec parse_flow_sequence_entry(taffy@parser@types:parser()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_sequence_entry(Parser) ->
    case taffy@parser@helpers:current(Parser) of
        {some, bracket_open} ->
            gleam@result:'try'(
                parse_flow_sequence(taffy@parser@helpers:advance(Parser)),
                fun(_use0) ->
                    {Seq_val, Parser@1} = _use0,
                    check_for_mapping_key(Seq_val, Parser@1)
                end
            );

        {some, brace_open} ->
            gleam@result:'try'(
                parse_flow_mapping(taffy@parser@helpers:advance(Parser)),
                fun(_use0@1) ->
                    {Map_val, Parser@2} = _use0@1,
                    check_for_mapping_key(Map_val, Parser@2)
                end
            );

        {some, {plain, S}} ->
            {Full_scalar, Parser@3} = collect_flow_plain_scalar_parts(
                taffy@parser@helpers:advance(Parser),
                S
            ),
            check_for_plain_mapping_key(Full_scalar, Parser@3);

        {some, {single_quoted, S@1}} ->
            check_for_quoted_mapping_key(
                S@1,
                taffy@parser@helpers:advance(Parser)
            );

        {some, {double_quoted, S@2}} ->
            check_for_quoted_mapping_key(
                S@2,
                taffy@parser@helpers:advance(Parser)
            );

        {some, {anchor, Name}} ->
            gleam@result:'try'(
                parse_flow_sequence_entry(
                    begin
                        _pipe = taffy@parser@helpers:advance(Parser),
                        taffy@parser@helpers:skip_whitespace(_pipe)
                    end
                ),
                fun(_use0@2) ->
                    {Val, Parser@4} = _use0@2,
                    Parser@5 = taffy@parser@types:register_anchor(
                        Parser@4,
                        Name,
                        Val
                    ),
                    {ok, {Val, Parser@5}}
                end
            );

        {some, {alias, Name@1}} ->
            Parser@6 = taffy@parser@helpers:advance(Parser),
            case taffy@parser@types:resolve_alias(Parser@6, Name@1) of
                {ok, {Val@1, Parser@7}} ->
                    {ok, {Val@1, Parser@7}};

                {error, <<"budget exceeded"/utf8>>} ->
                    {error,
                        {parse_error,
                            <<"Alias expansion budget exceeded (possible alias-bomb)"/utf8>>,
                            erlang:element(4, Parser@6)}};

                {error, _} ->
                    {error,
                        {parse_error,
                            <<"Unknown anchor: "/utf8, Name@1/binary>>,
                            erlang:element(4, Parser@6)}}
            end;

        {some, {tag, Tag}} ->
            Parser@8 = begin
                _pipe@1 = taffy@parser@helpers:advance(Parser),
                taffy@parser@helpers:skip_whitespace(_pipe@1)
            end,
            Is_str_tag = (Tag =:= <<"!!str"/utf8>>) orelse gleam_stdlib:contains_string(
                Tag,
                <<"tag:yaml.org,2002:str"/utf8>>
            ),
            case {taffy@parser@helpers:current(Parser@8), Is_str_tag} of
                {{some, comma}, true} ->
                    {ok, {{string, <<""/utf8>>}, Parser@8}};

                {{some, bracket_close}, true} ->
                    {ok, {{string, <<""/utf8>>}, Parser@8}};

                {{some, brace_close}, true} ->
                    {ok, {{string, <<""/utf8>>}, Parser@8}};

                {{some, eof}, true} ->
                    {ok, {{string, <<""/utf8>>}, Parser@8}};

                {none, true} ->
                    {ok, {{string, <<""/utf8>>}, Parser@8}};

                {_, _} ->
                    parse_flow_sequence_entry(Parser@8)
            end;

        {some, colon} ->
            gleam@result:'try'(
                parse_flow_value(
                    taffy@parser@helpers:skip_whitespace(
                        taffy@parser@helpers:advance(Parser)
                    )
                ),
                fun(_use0@3) ->
                    {Val@2, Parser@9} = _use0@3,
                    {ok, {{mapping, [{<<""/utf8>>, Val@2}]}, Parser@9}}
                end
            );

        {some, comma} ->
            {ok, {null, Parser}};

        {some, bracket_close} ->
            {ok, {null, Parser}};

        _ ->
            {ok, {null, Parser}}
    end.

-file("src/taffy/parser/flow.gleam", 199).
?DOC(false).
-spec check_for_quoted_mapping_key(binary(), taffy@parser@types:parser()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
check_for_quoted_mapping_key(S, Parser) ->
    case taffy@parser@helpers:current(Parser) of
        {some, colon} ->
            gleam@result:'try'(
                taffy@parser@helpers:skip_flow_whitespace(
                    taffy@parser@helpers:advance(Parser)
                ),
                fun(Parser@1) ->
                    gleam@result:'try'(
                        parse_flow_value(Parser@1),
                        fun(_use0) ->
                            {Val, Parser@2} = _use0,
                            {ok, {{mapping, [{S, Val}]}, Parser@2}}
                        end
                    )
                end
            );

        {some, {plain, P}} ->
            case gleam_stdlib:string_starts_with(P, <<":"/utf8>>) of
                true ->
                    Rest = gleam@string:drop_start(P, 1),
                    Val@1 = case Rest of
                        <<""/utf8>> ->
                            null;

                        _ ->
                            taffy@parser@scalar:parse_scalar(Rest)
                    end,
                    {ok,
                        {{mapping, [{S, Val@1}]},
                            taffy@parser@helpers:advance(Parser)}};

                false ->
                    {ok, {{string, S}, Parser}}
            end;

        {some, newline} ->
            {ok, {{string, S}, Parser}};

        {some, {indent, _}} ->
            {ok, {{string, S}, Parser}};

        _ ->
            {ok, {{string, S}, Parser}}
    end.

-file("src/taffy/parser/flow.gleam", 566).
?DOC(false).
-spec parse_flow_value(taffy@parser@types:parser()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_value(Parser) ->
    gleam@result:'try'(
        taffy@parser@helpers:skip_flow_whitespace(Parser),
        fun(Parser@1) -> case taffy@parser@helpers:current(Parser@1) of
                {some, bracket_open} ->
                    parse_flow_sequence(taffy@parser@helpers:advance(Parser@1));

                {some, brace_open} ->
                    parse_flow_mapping(taffy@parser@helpers:advance(Parser@1));

                {some, {plain, S}} ->
                    {ok,
                        {taffy@parser@scalar:parse_scalar(S),
                            taffy@parser@helpers:advance(Parser@1)}};

                {some, {single_quoted, S@1}} ->
                    {ok,
                        {{string, S@1}, taffy@parser@helpers:advance(Parser@1)}};

                {some, {double_quoted, S@1}} ->
                    {ok,
                        {{string, S@1}, taffy@parser@helpers:advance(Parser@1)}};

                {some, {anchor, Name}} ->
                    Parser@2 = begin
                        _pipe = taffy@parser@helpers:advance(Parser@1),
                        taffy@parser@helpers:skip_whitespace(_pipe)
                    end,
                    gleam@result:'try'(
                        parse_flow_value(Parser@2),
                        fun(_use0) ->
                            {Val, Parser@3} = _use0,
                            Parser@4 = taffy@parser@types:register_anchor(
                                Parser@3,
                                Name,
                                Val
                            ),
                            {ok, {Val, Parser@4}}
                        end
                    );

                {some, {alias, Name@1}} ->
                    Parser@5 = taffy@parser@helpers:advance(Parser@1),
                    case taffy@parser@types:resolve_alias(Parser@5, Name@1) of
                        {ok, {Val@1, Parser@6}} ->
                            {ok, {Val@1, Parser@6}};

                        {error, <<"budget exceeded"/utf8>>} ->
                            {error,
                                {parse_error,
                                    <<"Alias expansion budget exceeded (possible alias-bomb)"/utf8>>,
                                    erlang:element(4, Parser@5)}};

                        {error, _} ->
                            {error,
                                {parse_error,
                                    <<"Unknown anchor: "/utf8, Name@1/binary>>,
                                    erlang:element(4, Parser@5)}}
                    end;

                {some, {tag, Tag}} ->
                    Parser@7 = begin
                        _pipe@1 = taffy@parser@helpers:advance(Parser@1),
                        taffy@parser@helpers:skip_whitespace(_pipe@1)
                    end,
                    Is_str_tag = (Tag =:= <<"!!str"/utf8>>) orelse gleam_stdlib:contains_string(
                        Tag,
                        <<"tag:yaml.org,2002:str"/utf8>>
                    ),
                    case {taffy@parser@helpers:current(Parser@7), Is_str_tag} of
                        {{some, comma}, true} ->
                            {ok, {{string, <<""/utf8>>}, Parser@7}};

                        {{some, brace_close}, true} ->
                            {ok, {{string, <<""/utf8>>}, Parser@7}};

                        {{some, bracket_close}, true} ->
                            {ok, {{string, <<""/utf8>>}, Parser@7}};

                        {{some, eof}, true} ->
                            {ok, {{string, <<""/utf8>>}, Parser@7}};

                        {none, true} ->
                            {ok, {{string, <<""/utf8>>}, Parser@7}};

                        {_, _} ->
                            parse_flow_value(Parser@7)
                    end;

                _ ->
                    {ok, {null, Parser@1}}
            end end
    ).

-file("src/taffy/parser/flow.gleam", 269).
?DOC(false).
-spec parse_flow_mapping(taffy@parser@types:parser()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_mapping(Parser) ->
    gleam@result:'try'(
        taffy@parser@helpers:skip_flow_whitespace(Parser),
        fun(Parser@1) -> parse_flow_mapping_pairs(Parser@1, []) end
    ).

-file("src/taffy/parser/flow.gleam", 276).
?DOC(false).
-spec parse_flow_mapping_pairs(
    taffy@parser@types:parser(),
    list({binary(), taffy@value:yaml_value()})
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_mapping_pairs(Parser, Acc) ->
    gleam@result:'try'(
        taffy@parser@helpers:skip_flow_whitespace(Parser),
        fun(Parser@1) -> case taffy@parser@helpers:current(Parser@1) of
                {some, brace_close} ->
                    {ok,
                        {{mapping, lists:reverse(Acc)},
                            taffy@parser@helpers:advance(Parser@1)}};

                {some, eof} ->
                    {error,
                        {parse_error,
                            <<"Unterminated flow mapping"/utf8>>,
                            erlang:element(4, Parser@1)}};

                none ->
                    {error,
                        {parse_error,
                            <<"Unterminated flow mapping"/utf8>>,
                            erlang:element(4, Parser@1)}};

                {some, question} ->
                    parse_explicit_flow_mapping_pair(
                        taffy@parser@helpers:skip_whitespace(
                            taffy@parser@helpers:advance(Parser@1)
                        ),
                        Acc
                    );

                _ ->
                    gleam@result:'try'(
                        parse_flow_key_with_colon(Parser@1),
                        fun(_use0) ->
                            {Key, Parser@2} = _use0,
                            parse_flow_mapping_value(
                                Key,
                                taffy@parser@helpers:skip_whitespace(Parser@2),
                                Acc
                            )
                        end
                    )
            end end
    ).

-file("src/taffy/parser/flow.gleam", 299).
?DOC(false).
-spec parse_explicit_flow_mapping_pair(
    taffy@parser@types:parser(),
    list({binary(), taffy@value:yaml_value()})
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_explicit_flow_mapping_pair(Parser, Acc) ->
    case taffy@parser@helpers:current(Parser) of
        {some, brace_close} ->
            {ok,
                {{mapping, lists:reverse([{<<""/utf8>>, null} | Acc])},
                    taffy@parser@helpers:advance(Parser)}};

        {some, comma} ->
            parse_flow_mapping_pairs(
                taffy@parser@helpers:advance(Parser),
                [{<<""/utf8>>, null} | Acc]
            );

        {some, colon} ->
            parse_flow_mapping_colon_value(
                <<""/utf8>>,
                taffy@parser@helpers:skip_whitespace(
                    taffy@parser@helpers:advance(Parser)
                ),
                Acc
            );

        _ ->
            gleam@result:'try'(
                parse_flow_key_with_colon(Parser),
                fun(_use0) ->
                    {Key, Parser@1} = _use0,
                    Parser@2 = taffy@parser@helpers:skip_whitespace(Parser@1),
                    case taffy@parser@helpers:current(Parser@2) of
                        {some, colon} ->
                            parse_flow_mapping_colon_value(
                                Key,
                                taffy@parser@helpers:skip_whitespace(
                                    taffy@parser@helpers:advance(Parser@2)
                                ),
                                Acc
                            );

                        {some, comma} ->
                            parse_flow_mapping_pairs(
                                taffy@parser@helpers:advance(Parser@2),
                                [{Key, null} | Acc]
                            );

                        {some, brace_close} ->
                            {ok,
                                {{mapping, lists:reverse([{Key, null} | Acc])},
                                    taffy@parser@helpers:advance(Parser@2)}};

                        _ ->
                            {error,
                                {parse_error,
                                    <<"Expected ':', ',' or '}'"/utf8>>,
                                    erlang:element(4, Parser@2)}}
                    end
                end
            )
    end.

-file("src/taffy/parser/flow.gleam", 410).
?DOC(false).
-spec parse_flow_key_with_colon(taffy@parser@types:parser()) -> {ok,
        {binary(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_key_with_colon(Parser) ->
    case taffy@parser@helpers:current(Parser) of
        {some, {plain, S}} ->
            collect_flow_key_parts(taffy@parser@helpers:advance(Parser), S);

        {some, {single_quoted, S@1}} ->
            {ok, {S@1, taffy@parser@helpers:advance(Parser)}};

        {some, {double_quoted, S@1}} ->
            {ok, {S@1, taffy@parser@helpers:advance(Parser)}};

        {some, bracket_open} ->
            parse_flow_collection_key(Parser, fun parse_flow_sequence/1);

        {some, brace_open} ->
            parse_flow_collection_key(Parser, fun parse_flow_mapping/1);

        {some, {anchor, Name}} ->
            parse_anchored_flow_key(Parser, Name);

        {some, {alias, Name@1}} ->
            parse_alias_flow_key(Parser, Name@1);

        {some, {tag, Tag}} ->
            parse_tagged_flow_key(Parser, Tag);

        {some, colon} ->
            {ok, {<<""/utf8>>, Parser}};

        _ ->
            {error,
                {parse_error,
                    <<"Expected mapping key"/utf8>>,
                    erlang:element(4, Parser)}}
    end.

-file("src/taffy/parser/flow.gleam", 437).
?DOC(false).
-spec parse_anchored_flow_key(taffy@parser@types:parser(), binary()) -> {ok,
        {binary(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_anchored_flow_key(Parser, Name) ->
    Parser@1 = begin
        _pipe = taffy@parser@helpers:advance(Parser),
        taffy@parser@helpers:skip_whitespace(_pipe)
    end,
    case taffy@parser@helpers:current(Parser@1) of
        {some, bracket_open} ->
            Parse_fn = case taffy@parser@helpers:current(Parser@1) of
                {some, bracket_open} ->
                    fun parse_flow_sequence/1;

                _ ->
                    fun parse_flow_mapping/1
            end,
            gleam@result:'try'(
                Parse_fn(taffy@parser@helpers:advance(Parser@1)),
                fun(_use0) ->
                    {Val, Parser@2} = _use0,
                    Parser@3 = taffy@parser@types:register_anchor(
                        Parser@2,
                        Name,
                        Val
                    ),
                    {ok,
                        {taffy@parser@scalar:value_to_key_string(Val), Parser@3}}
                end
            );

        {some, brace_open} ->
            Parse_fn = case taffy@parser@helpers:current(Parser@1) of
                {some, bracket_open} ->
                    fun parse_flow_sequence/1;

                _ ->
                    fun parse_flow_mapping/1
            end,
            gleam@result:'try'(
                Parse_fn(taffy@parser@helpers:advance(Parser@1)),
                fun(_use0) ->
                    {Val, Parser@2} = _use0,
                    Parser@3 = taffy@parser@types:register_anchor(
                        Parser@2,
                        Name,
                        Val
                    ),
                    {ok,
                        {taffy@parser@scalar:value_to_key_string(Val), Parser@3}}
                end
            );

        _ ->
            gleam@result:'try'(
                parse_flow_key_with_colon(Parser@1),
                fun(_use0@1) ->
                    {Key, Parser@4} = _use0@1,
                    Parser@5 = taffy@parser@types:register_anchor(
                        Parser@4,
                        Name,
                        {string, Key}
                    ),
                    {ok, {Key, Parser@5}}
                end
            )
    end.

-file("src/taffy/parser/flow.gleam", 16).
?DOC(false).
-spec parse_flow_sequence(taffy@parser@types:parser()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_sequence(Parser) ->
    gleam@result:'try'(
        taffy@parser@helpers:skip_flow_whitespace(Parser),
        fun(Parser@1) -> parse_flow_sequence_items(Parser@1, []) end
    ).

-file("src/taffy/parser/flow.gleam", 23).
?DOC(false).
-spec parse_flow_sequence_items(
    taffy@parser@types:parser(),
    list(taffy@value:yaml_value())
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_sequence_items(Parser, Acc) ->
    gleam@result:'try'(
        taffy@parser@helpers:skip_flow_whitespace(Parser),
        fun(Parser@1) -> case taffy@parser@helpers:current(Parser@1) of
                {some, bracket_close} ->
                    {ok,
                        {{sequence, lists:reverse(Acc)},
                            taffy@parser@helpers:advance(Parser@1)}};

                {some, eof} ->
                    {error,
                        {parse_error,
                            <<"Unterminated flow sequence"/utf8>>,
                            erlang:element(4, Parser@1)}};

                none ->
                    {error,
                        {parse_error,
                            <<"Unterminated flow sequence"/utf8>>,
                            erlang:element(4, Parser@1)}};

                {some, comma} ->
                    case Acc of
                        [] ->
                            {error,
                                {parse_error,
                                    <<"Invalid leading comma in flow sequence"/utf8>>,
                                    erlang:element(4, Parser@1)}};

                        _ ->
                            {error,
                                {parse_error,
                                    <<"Invalid extra comma in flow sequence"/utf8>>,
                                    erlang:element(4, Parser@1)}}
                    end;

                {some, question} ->
                    gleam@result:'try'(
                        parse_flow_sequence_single_pair(
                            taffy@parser@helpers:skip_whitespace(
                                taffy@parser@helpers:advance(Parser@1)
                            ),
                            true
                        ),
                        fun(_use0) ->
                            {Val, Parser@2} = _use0,
                            continue_flow_sequence(Val, Parser@2, Acc)
                        end
                    );

                _ ->
                    gleam@result:'try'(
                        parse_flow_sequence_entry(Parser@1),
                        fun(_use0@1) ->
                            {Val@1, Parser@3} = _use0@1,
                            continue_flow_sequence(Val@1, Parser@3, Acc)
                        end
                    )
            end end
    ).

-file("src/taffy/parser/flow.gleam", 60).
?DOC(false).
-spec continue_flow_sequence(
    taffy@value:yaml_value(),
    taffy@parser@types:parser(),
    list(taffy@value:yaml_value())
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
continue_flow_sequence(Val, Parser, Acc) ->
    gleam@result:'try'(
        taffy@parser@helpers:skip_flow_whitespace(Parser),
        fun(Parser@1) -> case taffy@parser@helpers:current(Parser@1) of
                {some, comma} ->
                    parse_flow_sequence_items(
                        taffy@parser@helpers:advance(Parser@1),
                        [Val | Acc]
                    );

                {some, bracket_close} ->
                    {ok,
                        {{sequence, lists:reverse([Val | Acc])},
                            taffy@parser@helpers:advance(Parser@1)}};

                _ ->
                    {error,
                        {parse_error,
                            <<"Expected ',' or ']'"/utf8>>,
                            erlang:element(4, Parser@1)}}
            end end
    ).

-file("src/taffy/parser/flow.gleam", 148).
?DOC(false).
-spec check_for_mapping_key(
    taffy@value:yaml_value(),
    taffy@parser@types:parser()
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
check_for_mapping_key(Val, Parser) ->
    Parser@1 = taffy@parser@helpers:skip_whitespace(Parser),
    case taffy@parser@helpers:current(Parser@1) of
        {some, colon} ->
            Key = taffy@parser@scalar:value_to_key_string(Val),
            gleam@result:'try'(
                parse_flow_value(
                    taffy@parser@helpers:skip_whitespace(
                        taffy@parser@helpers:advance(Parser@1)
                    )
                ),
                fun(_use0) ->
                    {Map_val, Parser@2} = _use0,
                    {ok, {{mapping, [{Key, Map_val}]}, Parser@2}}
                end
            );

        {some, {plain, P}} ->
            check_adjacent_colon(Val, P, Parser@1);

        _ ->
            {ok, {Val, Parser@1}}
    end.

-file("src/taffy/parser/flow.gleam", 185).
?DOC(false).
-spec check_for_plain_mapping_key(binary(), taffy@parser@types:parser()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
check_for_plain_mapping_key(Full_scalar, Parser) ->
    case taffy@parser@helpers:current(Parser) of
        {some, colon} ->
            gleam@result:'try'(
                taffy@parser@helpers:skip_flow_whitespace(
                    taffy@parser@helpers:advance(Parser)
                ),
                fun(Parser@1) ->
                    gleam@result:'try'(
                        parse_flow_value(Parser@1),
                        fun(_use0) ->
                            {Val, Parser@2} = _use0,
                            {ok, {{mapping, [{Full_scalar, Val}]}, Parser@2}}
                        end
                    )
                end
            );

        _ ->
            {ok, {taffy@parser@scalar:parse_scalar(Full_scalar), Parser}}
    end.

-file("src/taffy/parser/flow.gleam", 228).
?DOC(false).
-spec parse_explicit_key_value(binary(), taffy@parser@types:parser()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_explicit_key_value(Key, Parser) ->
    case taffy@parser@helpers:current(Parser) of
        {some, colon} ->
            gleam@result:'try'(
                parse_flow_value(
                    taffy@parser@helpers:skip_whitespace(
                        taffy@parser@helpers:advance(Parser)
                    )
                ),
                fun(_use0) ->
                    {Val, Parser@1} = _use0,
                    {ok, {{mapping, [{Key, Val}]}, Parser@1}}
                end
            );

        _ ->
            {ok, {{mapping, [{Key, null}]}, Parser}}
    end.

-file("src/taffy/parser/flow.gleam", 243).
?DOC(false).
-spec parse_flow_sequence_single_pair(taffy@parser@types:parser(), boolean()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_sequence_single_pair(Parser, _) ->
    case taffy@parser@helpers:current(Parser) of
        {some, {plain, S}} ->
            {Full_key, Parser@1} = collect_flow_plain_scalar_parts(
                taffy@parser@helpers:advance(Parser),
                S
            ),
            parse_explicit_key_value(
                Full_key,
                taffy@parser@helpers:skip_whitespace(Parser@1)
            );

        {some, {single_quoted, S@1}} ->
            parse_explicit_key_value(
                S@1,
                taffy@parser@helpers:skip_whitespace(
                    taffy@parser@helpers:advance(Parser)
                )
            );

        {some, {double_quoted, S@1}} ->
            parse_explicit_key_value(
                S@1,
                taffy@parser@helpers:skip_whitespace(
                    taffy@parser@helpers:advance(Parser)
                )
            );

        {some, colon} ->
            gleam@result:'try'(
                parse_flow_value(
                    taffy@parser@helpers:skip_whitespace(
                        taffy@parser@helpers:advance(Parser)
                    )
                ),
                fun(_use0) ->
                    {Val, Parser@2} = _use0,
                    {ok, {{mapping, [{<<""/utf8>>, Val}]}, Parser@2}}
                end
            );

        _ ->
            {ok, {{mapping, [{<<""/utf8>>, null}]}, Parser}}
    end.

-file("src/taffy/parser/flow.gleam", 359).
?DOC(false).
-spec continue_flow_mapping(
    binary(),
    taffy@value:yaml_value(),
    taffy@parser@types:parser(),
    list({binary(), taffy@value:yaml_value()})
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
continue_flow_mapping(Key, Val, Parser, Acc) ->
    Acc@1 = [{Key, Val} | Acc],
    gleam@result:'try'(
        taffy@parser@helpers:skip_flow_whitespace(Parser),
        fun(Parser@1) -> case taffy@parser@helpers:current(Parser@1) of
                {some, comma} ->
                    parse_flow_mapping_pairs(
                        taffy@parser@helpers:advance(Parser@1),
                        Acc@1
                    );

                {some, brace_close} ->
                    {ok,
                        {{mapping, lists:reverse(Acc@1)},
                            taffy@parser@helpers:advance(Parser@1)}};

                _ ->
                    {error,
                        {parse_error,
                            <<"Expected ',' or '}'"/utf8>>,
                            erlang:element(4, Parser@1)}}
            end end
    ).

-file("src/taffy/parser/flow.gleam", 339).
?DOC(false).
-spec parse_flow_mapping_colon_value(
    binary(),
    taffy@parser@types:parser(),
    list({binary(), taffy@value:yaml_value()})
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_mapping_colon_value(Key, Parser, Acc) ->
    case taffy@parser@helpers:current(Parser) of
        {some, comma} ->
            parse_flow_mapping_pairs(
                taffy@parser@helpers:advance(Parser),
                [{Key, null} | Acc]
            );

        {some, brace_close} ->
            {ok,
                {{mapping, lists:reverse([{Key, null} | Acc])},
                    taffy@parser@helpers:advance(Parser)}};

        _ ->
            gleam@result:'try'(
                parse_flow_value(Parser),
                fun(_use0) ->
                    {Val, Parser@1} = _use0,
                    continue_flow_mapping(Key, Val, Parser@1, Acc)
                end
            )
    end.

-file("src/taffy/parser/flow.gleam", 375).
?DOC(false).
-spec parse_flow_mapping_value(
    binary(),
    taffy@parser@types:parser(),
    list({binary(), taffy@value:yaml_value()})
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_mapping_value(Key, Parser, Acc) ->
    case taffy@parser@helpers:current(Parser) of
        {some, {plain, S}} ->
            case gleam_stdlib:string_starts_with(S, <<":"/utf8>>) of
                true ->
                    Rest = gleam@string:drop_start(S, 1),
                    Val = case Rest of
                        <<""/utf8>> ->
                            null;

                        _ ->
                            taffy@parser@scalar:parse_scalar(Rest)
                    end,
                    continue_flow_mapping(
                        Key,
                        Val,
                        taffy@parser@helpers:advance(Parser),
                        Acc
                    );

                false ->
                    {error,
                        {parse_error,
                            <<"Expected ':', ',' or '}'"/utf8>>,
                            erlang:element(4, Parser)}}
            end;

        {some, colon} ->
            parse_flow_mapping_colon_value(
                Key,
                taffy@parser@helpers:skip_whitespace(
                    taffy@parser@helpers:advance(Parser)
                ),
                Acc
            );

        {some, comma} ->
            parse_flow_mapping_pairs(
                taffy@parser@helpers:advance(Parser),
                [{Key, null} | Acc]
            );

        {some, brace_close} ->
            Acc@1 = [{Key, null} | Acc],
            {ok,
                {{mapping, lists:reverse(Acc@1)},
                    taffy@parser@helpers:advance(Parser)}};

        _ ->
            {error,
                {parse_error,
                    <<"Expected ':', ',' or '}'"/utf8>>,
                    erlang:element(4, Parser)}}
    end.

-file("src/taffy/parser/flow.gleam", 476).
?DOC(false).
-spec parse_tagged_flow_key(taffy@parser@types:parser(), binary()) -> {ok,
        {binary(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_tagged_flow_key(Parser, Tag) ->
    Parser@1 = begin
        _pipe = taffy@parser@helpers:advance(Parser),
        taffy@parser@helpers:skip_whitespace(_pipe)
    end,
    Is_str_tag = (Tag =:= <<"!!str"/utf8>>) orelse gleam_stdlib:contains_string(
        Tag,
        <<"tag:yaml.org,2002:str"/utf8>>
    ),
    case {taffy@parser@helpers:current(Parser@1), Is_str_tag} of
        {{some, colon}, true} ->
            {ok, {<<""/utf8>>, Parser@1}};

        {_, _} ->
            parse_flow_key_with_colon(Parser@1)
    end.