-module(taffy@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/taffy/parser.gleam").
-export([parse/1, parse_with/3, parse_all/1, parse_all_with/3]).

-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.gleam", 18).
?DOC(false).
-spec new(list(taffy@lexer:token())) -> taffy@parser@types:parser().
new(Tokens) ->
    taffy@parser@types:new(Tokens).

-file("src/taffy/parser.gleam", 22).
?DOC(false).
-spec with_limits(taffy@parser@types:parser(), integer(), integer()) -> taffy@parser@types:parser().
with_limits(Parser, Alias_budget, Max_depth) ->
    {parser,
        erlang:element(2, Parser),
        erlang:element(3, Parser),
        erlang:element(4, Parser),
        erlang:element(5, Parser),
        erlang:element(6, Parser),
        erlang:element(7, Parser),
        erlang:element(8, Parser),
        erlang:element(9, Parser),
        erlang:element(10, Parser),
        Alias_budget,
        erlang:element(12, Parser),
        Max_depth}.

-file("src/taffy/parser.gleam", 77).
?DOC(false).
-spec validate_directive(binary(), boolean(), integer()) -> {ok, nil} |
    {error, taffy@parser@types:parse_error()}.
validate_directive(Content, Is_yaml, Pos) ->
    case Is_yaml of
        true ->
            Before_comment = case gleam@string:split_once(
                Content,
                <<" #"/utf8>>
            ) of
                {ok, {Before, _}} ->
                    gleam@string:trim(Before);

                {error, _} ->
                    gleam@string:trim(Content)
            end,
            Has_invalid_hash = gleam_stdlib:contains_string(
                Before_comment,
                <<"#"/utf8>>
            ),
            Parts = begin
                _pipe = gleam@string:split(Before_comment, <<" "/utf8>>),
                gleam@list:filter(_pipe, fun(P) -> P /= <<""/utf8>> end)
            end,
            Too_many_parts = erlang:length(Parts) > 2,
            case Has_invalid_hash orelse Too_many_parts of
                true ->
                    {error,
                        {parse_error,
                            <<"Invalid %YAML directive: %"/utf8,
                                Content/binary>>,
                            Pos}};

                false ->
                    {ok, nil}
            end;

        false ->
            {ok, nil}
    end.

-file("src/taffy/parser.gleam", 148).
?DOC(false).
-spec extract_tag_handle(binary()) -> binary().
extract_tag_handle(Directive_content) ->
    After_tag = gleam@string:drop_start(Directive_content, 4),
    Trimmed = gleam@string:trim_start(After_tag),
    case gleam@string:split_once(Trimmed, <<" "/utf8>>) of
        {ok, {Handle, _}} ->
            Handle;

        {error, _} ->
            Trimmed
    end.

-file("src/taffy/parser.gleam", 107).
?DOC(false).
-spec consume_directives_loop(taffy@parser@types:parser()) -> {ok,
        taffy@parser@types:parser()} |
    {error, taffy@parser@types:parse_error()}.
consume_directives_loop(Parser) ->
    Parser@1 = taffy@parser@helpers:skip_newlines_and_comments(Parser),
    case taffy@parser@helpers:current(Parser@1) of
        {some, {directive, D}} ->
            Is_yaml_dir = gleam_stdlib:string_starts_with(D, <<"YAML"/utf8>>),
            Is_tag_dir = gleam_stdlib:string_starts_with(D, <<"TAG"/utf8>>),
            gleam@result:'try'(
                validate_directive(D, Is_yaml_dir, erlang:element(4, Parser@1)),
                fun(_) ->
                    Parser@2 = case Is_tag_dir of
                        true ->
                            Handle = extract_tag_handle(D),
                            {parser,
                                erlang:element(2, Parser@1),
                                erlang:element(3, Parser@1),
                                erlang:element(4, Parser@1),
                                erlang:element(5, Parser@1),
                                erlang:element(6, Parser@1),
                                erlang:element(7, Parser@1),
                                erlang:element(8, Parser@1),
                                erlang:element(9, Parser@1),
                                [Handle | erlang:element(10, Parser@1)],
                                erlang:element(11, Parser@1),
                                erlang:element(12, Parser@1),
                                erlang:element(13, Parser@1)};

                        false ->
                            Parser@1
                    end,
                    Parser@3 = taffy@parser@helpers:advance(Parser@2),
                    Parser@4 = taffy@parser@helpers:skip_newlines_and_comments(
                        Parser@3
                    ),
                    case taffy@parser@helpers:current(Parser@4) of
                        {some, doc_start} ->
                            {ok, Parser@4};

                        {some, {directive, D2}} ->
                            case Is_yaml_dir andalso gleam_stdlib:string_starts_with(
                                D2,
                                <<"YAML"/utf8>>
                            ) of
                                true ->
                                    {error,
                                        {parse_error,
                                            <<"Duplicate %YAML directive"/utf8>>,
                                            erlang:element(4, Parser@4)}};

                                false ->
                                    consume_directives_loop(Parser@4)
                            end;

                        {some, doc_end} ->
                            {error,
                                {parse_error,
                                    <<"Directive must be followed by document start '---'"/utf8>>,
                                    erlang:element(4, Parser@4)}};

                        none ->
                            {error,
                                {parse_error,
                                    <<"Directive must be followed by document start '---'"/utf8>>,
                                    erlang:element(4, Parser@4)}};

                        {some, eof} ->
                            {error,
                                {parse_error,
                                    <<"Directive must be followed by document start '---'"/utf8>>,
                                    erlang:element(4, Parser@4)}};

                        _ ->
                            {ok, Parser@4}
                    end
                end
            );

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

-file("src/taffy/parser.gleam", 102).
?DOC(false).
-spec consume_directives(taffy@parser@types:parser()) -> {ok,
        taffy@parser@types:parser()} |
    {error, taffy@parser@types:parse_error()}.
consume_directives(Parser) ->
    Parser@1 = {parser,
        erlang:element(2, Parser),
        erlang:element(3, Parser),
        erlang:element(4, Parser),
        erlang:element(5, Parser),
        erlang:element(6, Parser),
        erlang:element(7, Parser),
        erlang:element(8, Parser),
        erlang:element(9, Parser),
        [],
        erlang:element(11, Parser),
        erlang:element(12, Parser),
        erlang:element(13, Parser)},
    consume_directives_loop(Parser@1).

-file("src/taffy/parser.gleam", 157).
?DOC(false).
-spec validate_tag_handle(binary(), taffy@parser@types:parser()) -> {ok, nil} |
    {error, taffy@parser@types:parse_error()}.
validate_tag_handle(Tag, Parser) ->
    case (gleam_stdlib:string_starts_with(Tag, <<"!<"/utf8>>) orelse (Tag =:= <<"!"/utf8>>))
    orelse gleam_stdlib:string_starts_with(Tag, <<"!!"/utf8>>) of
        true ->
            {ok, nil};

        false ->
            case gleam_stdlib:string_starts_with(Tag, <<"!"/utf8>>) of
                false ->
                    {ok, nil};

                true ->
                    Rest = gleam@string:drop_start(Tag, 1),
                    case gleam@string:split_once(Rest, <<"!"/utf8>>) of
                        {ok, {Handle_body, _}} ->
                            Handle = <<<<"!"/utf8, Handle_body/binary>>/binary,
                                "!"/utf8>>,
                            case gleam@list:contains(
                                erlang:element(10, Parser),
                                Handle
                            ) of
                                true ->
                                    {ok, nil};

                                false ->
                                    {error,
                                        {parse_error,
                                            <<"Undefined tag handle: "/utf8,
                                                Handle/binary>>,
                                            erlang:element(4, Parser)}}
                            end;

                        {error, _} ->
                            {ok, nil}
                    end
            end
    end.

-file("src/taffy/parser.gleam", 187).
?DOC(false).
-spec check_doc_start_anchor(taffy@parser@types:parser()) -> {ok, nil} |
    {error, taffy@parser@types:parse_error()}.
check_doc_start_anchor(Parser) ->
    case taffy@parser@helpers:current(Parser) of
        {some, {anchor, _}} ->
            After_anchor = taffy@parser@helpers:advance(Parser),
            case taffy@parser@helpers:current(After_anchor) of
                {some, {plain, _}} ->
                    After_plain = taffy@parser@helpers:advance(After_anchor),
                    case taffy@parser@helpers:current(After_plain) of
                        {some, colon} ->
                            {error,
                                {parse_error,
                                    <<"Anchor before mapping on document start line is ambiguous"/utf8>>,
                                    erlang:element(4, Parser)}};

                        _ ->
                            {ok, nil}
                    end;

                _ ->
                    {ok, nil}
            end;

        _ ->
            {ok, nil}
    end.

-file("src/taffy/parser.gleam", 210).
?DOC(false).
-spec check_after_doc_end(taffy@parser@types:parser()) -> {ok,
        taffy@parser@types:parser()} |
    {error, taffy@parser@types:parse_error()}.
check_after_doc_end(Parser) ->
    case taffy@parser@helpers:is_terminator(
        taffy@parser@helpers:current(Parser)
    ) of
        true ->
            {ok, Parser};

        false ->
            {error,
                {parse_error,
                    <<"Invalid content on same line as document end marker '...'"/utf8>>,
                    erlang:element(4, Parser)}}
    end.

-file("src/taffy/parser.gleam", 677).
?DOC(false).
-spec is_sequence_dash(taffy@parser@types:parser(), integer()) -> boolean().
is_sequence_dash(Parser, N) ->
    case erlang:element(6, Parser) of
        {some, Entry_indent} when (N > Entry_indent) andalso (N =:= 0) ->
            true;

        {some, Entry_indent@1} when N =:= Entry_indent@1 ->
            true;

        {some, _} ->
            false;

        none ->
            true
    end.

-file("src/taffy/parser.gleam", 686).
?DOC(false).
-spec should_absorb_dash_in_scalar(
    gleam@option:option(integer()),
    integer(),
    integer()
) -> boolean().
should_absorb_dash_in_scalar(Seq_entry_indent, N, Min_indent) ->
    case Seq_entry_indent of
        {some, Entry_indent} ->
            (N > Entry_indent) andalso (N =:= Min_indent);

        none ->
            false
    end.

-file("src/taffy/parser.gleam", 762).
?DOC(false).
-spec collect_plain_scalar_from_colon(taffy@parser@types:parser()) -> {binary(),
    taffy@parser@types:parser()}.
collect_plain_scalar_from_colon(Parser) ->
    case taffy@parser@helpers:current(Parser) of
        {some, colon} ->
            {Rest, Parser@1} = collect_plain_scalar_from_colon(
                taffy@parser@helpers:advance(Parser)
            ),
            {<<":"/utf8, Rest/binary>>, Parser@1};

        {some, comma} ->
            {Rest@1, Parser@2} = collect_plain_scalar_from_colon(
                taffy@parser@helpers:advance(Parser)
            ),
            {<<","/utf8, Rest@1/binary>>, Parser@2};

        {some, {plain, S}} ->
            {Rest@2, Parser@3} = collect_plain_scalar_from_colon(
                taffy@parser@helpers:advance(Parser)
            ),
            {<<S/binary, Rest@2/binary>>, Parser@3};

        _ ->
            {<<""/utf8>>, Parser}
    end.

-file("src/taffy/parser.gleam", 780).
?DOC(false).
-spec collect_block_plain_key(taffy@parser@types:parser(), binary()) -> {binary(),
    taffy@parser@types:parser()}.
collect_block_plain_key(Parser, Acc) ->
    case taffy@parser@helpers:current(Parser) of
        {some, comma} ->
            collect_block_plain_key(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, ","/utf8>>
            );

        {some, bracket_open} ->
            collect_block_plain_key(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, "["/utf8>>
            );

        {some, bracket_close} ->
            collect_block_plain_key(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, "]"/utf8>>
            );

        {some, brace_open} ->
            collect_block_plain_key(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, "{"/utf8>>
            );

        {some, brace_close} ->
            collect_block_plain_key(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, "}"/utf8>>
            );

        {some, colon} ->
            After_colon = taffy@parser@helpers:advance(Parser),
            case taffy@parser@helpers:current(After_colon) of
                {some, bracket_close} ->
                    collect_block_plain_key(
                        After_colon,
                        <<Acc/binary, ":"/utf8>>
                    );

                {some, brace_close} ->
                    collect_block_plain_key(
                        After_colon,
                        <<Acc/binary, ":"/utf8>>
                    );

                {some, colon} ->
                    collect_block_plain_key(
                        After_colon,
                        <<Acc/binary, ":"/utf8>>
                    );

                {some, comma} ->
                    collect_block_plain_key(
                        After_colon,
                        <<Acc/binary, ":"/utf8>>
                    );

                _ ->
                    {Acc, Parser}
            end;

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

        _ ->
            {Acc, Parser}
    end.

-file("src/taffy/parser.gleam", 809).
?DOC(false).
-spec append_continuation(binary(), binary()) -> binary().
append_continuation(Acc, Fragment) ->
    case gleam_stdlib:string_ends_with(Acc, <<"\n"/utf8>>) of
        true ->
            <<Acc/binary, Fragment/binary>>;

        false ->
            <<<<Acc/binary, " "/utf8>>/binary, Fragment/binary>>
    end.

-file("src/taffy/parser.gleam", 819).
?DOC(false).
-spec token_as_scalar_fragment(taffy@lexer:token()) -> gleam@option:option(binary()).
token_as_scalar_fragment(Token) ->
    case Token of
        {plain, S} ->
            {some, S};

        {tag, S@1} ->
            {some, S@1};

        {anchor, S@2} ->
            {some, <<"&"/utf8, S@2/binary>>};

        _ ->
            none
    end.

-file("src/taffy/parser.gleam", 1039).
?DOC(false).
-spec is_inline_value_token(gleam@option:option(taffy@lexer:token())) -> boolean().
is_inline_value_token(Token) ->
    not taffy@parser@helpers:is_terminator(Token).

-file("src/taffy/parser.gleam", 1043).
?DOC(false).
-spec is_mapping_key(taffy@parser@types:parser()) -> boolean().
is_mapping_key(Parser) ->
    case taffy@parser@helpers:current(Parser) of
        {some, {plain, _}} ->
            After_scalar = taffy@parser@helpers:advance(Parser),
            case taffy@parser@helpers:current(After_scalar) of
                {some, colon} ->
                    true;

                _ ->
                    false
            end;

        {some, {single_quoted, _}} ->
            After_scalar = taffy@parser@helpers:advance(Parser),
            case taffy@parser@helpers:current(After_scalar) of
                {some, colon} ->
                    true;

                _ ->
                    false
            end;

        {some, {double_quoted, _}} ->
            After_scalar = taffy@parser@helpers:advance(Parser),
            case taffy@parser@helpers:current(After_scalar) of
                {some, colon} ->
                    true;

                _ ->
                    false
            end;

        _ ->
            false
    end.

-file("src/taffy/parser.gleam", 318).
?DOC(false).
-spec parse_value_dispatch(taffy@parser@types:parser(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_value_dispatch(Parser, Min_indent) ->
    case taffy@parser@helpers:current(Parser) of
        {some, {comment, _}} ->
            parse_value(taffy@parser@helpers:advance(Parser), Min_indent);

        {some, newline} ->
            parse_value_after_newline(Parser, Min_indent);

        none ->
            {ok, {null, Parser}};

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

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

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

        {some, {directive, _}} ->
            {ok, {null, Parser}};

        {some, {anchor, Name}} ->
            parse_anchored_value(
                taffy@parser@helpers:advance(Parser),
                Name,
                Min_indent
            );

        {some, {alias, Name@1}} ->
            parse_alias_value(
                taffy@parser@helpers:advance(Parser),
                Name@1,
                Min_indent
            );

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

        {some, bracket_open} ->
            parse_flow_sequence_value(Parser, Min_indent);

        {some, brace_open} ->
            parse_flow_mapping_value(Parser, Min_indent);

        {some, dash} ->
            Dash_col = case Min_indent of
                0 ->
                    {some, 0};

                _ ->
                    none
            end,
            taffy@parser@block:parse_block_sequence_at(
                Parser,
                Min_indent,
                Dash_col,
                fun parse_value/2
            );

        {some, question} ->
            taffy@parser@explicit:parse_explicit_mapping(
                Parser,
                Min_indent,
                fun parse_value/2
            );

        {some, colon} ->
            parse_colon_value(Parser, Min_indent);

        {some, {literal, Content}} ->
            {ok, {{string, Content}, taffy@parser@helpers:advance(Parser)}};

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

        {some, {plain, S}} ->
            parse_plain_value(Parser, S, Min_indent);

        {some, {single_quoted, S@1}} ->
            parse_quoted_value(Parser, S@1, Min_indent);

        {some, {double_quoted, S@1}} ->
            parse_quoted_value(Parser, S@1, Min_indent);

        {some, {indent, N}} when N >= Min_indent ->
            parse_indented_value(Parser, N, Min_indent);

        {some, {indent, _}} ->
            {ok, {null, Parser}};

        {some, Token} ->
            {error,
                {parse_error,
                    <<"Unexpected token: "/utf8,
                        (taffy@parser@helpers:token_for_error(Token))/binary>>,
                    erlang:element(4, Parser)}}
    end.

-file("src/taffy/parser.gleam", 657).
?DOC(false).
-spec parse_indented_value(taffy@parser@types:parser(), integer(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_indented_value(Parser, N, Min_indent) ->
    Parser@1 = begin
        _record = taffy@parser@helpers:advance(Parser),
        {parser,
            erlang:element(2, _record),
            erlang:element(3, _record),
            erlang:element(4, _record),
            erlang:element(5, _record),
            erlang:element(6, _record),
            false,
            erlang:element(8, _record),
            erlang:element(9, _record),
            erlang:element(10, _record),
            erlang:element(11, _record),
            erlang:element(12, _record),
            erlang:element(13, _record)}
    end,
    case taffy@parser@helpers:current(Parser@1) of
        {some, dash} ->
            case is_sequence_dash(Parser@1, N) of
                true ->
                    taffy@parser@block:parse_block_sequence_at(
                        Parser@1,
                        N,
                        {some, N},
                        fun parse_value/2
                    );

                false ->
                    parse_value(Parser@1, Min_indent)
            end;

        {some, {plain, _}} ->
            parse_value_after_indent(Parser@1, N, Min_indent);

        {some, {single_quoted, _}} ->
            parse_value_after_indent(Parser@1, N, Min_indent);

        {some, {double_quoted, _}} ->
            parse_value_after_indent(Parser@1, N, Min_indent);

        _ ->
            parse_value(Parser@1, Min_indent)
    end.

-file("src/taffy/parser.gleam", 702).
?DOC(false).
-spec parse_value_after_indent(
    taffy@parser@types:parser(),
    integer(),
    integer()
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_value_after_indent(Parser, N, Min_indent) ->
    case taffy@parser@helpers:current(Parser) of
        {some, {plain, S}} ->
            {Full_key, After_key} = collect_block_plain_key(
                taffy@parser@helpers:advance(Parser),
                S
            ),
            case taffy@parser@helpers:current(After_key) of
                {some, colon} ->
                    After_colon = taffy@parser@helpers:advance(After_key),
                    case taffy@parser@helpers:current(After_colon) of
                        {some, {plain, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, {single_quoted, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, {double_quoted, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, newline} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, {indent, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, eof} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, {comment, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, {anchor, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, {alias, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, {tag, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, dash} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, question} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, {literal, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, {folded, _}} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, bracket_open} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        {some, brace_open} ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        none ->
                            taffy@parser@block:parse_block_mapping_from_key_col(
                                Full_key,
                                After_colon,
                                N,
                                {some, N},
                                fun parse_value/2
                            );

                        _ ->
                            parse_value(Parser, Min_indent)
                    end;

                _ ->
                    parse_value(Parser, Min_indent)
            end;

        {some, {single_quoted, S@1}} ->
            After_key@1 = taffy@parser@helpers:advance(Parser),
            case taffy@parser@helpers:current(After_key@1) of
                {some, colon} ->
                    taffy@parser@block:parse_block_mapping_from_key_col(
                        S@1,
                        taffy@parser@helpers:advance(After_key@1),
                        N,
                        {some, N},
                        fun parse_value/2
                    );

                _ ->
                    parse_value(Parser, Min_indent)
            end;

        {some, {double_quoted, S@1}} ->
            After_key@1 = taffy@parser@helpers:advance(Parser),
            case taffy@parser@helpers:current(After_key@1) of
                {some, colon} ->
                    taffy@parser@block:parse_block_mapping_from_key_col(
                        S@1,
                        taffy@parser@helpers:advance(After_key@1),
                        N,
                        {some, N},
                        fun parse_value/2
                    );

                _ ->
                    parse_value(Parser, Min_indent)
            end;

        _ ->
            parse_value(Parser, Min_indent)
    end.

-file("src/taffy/parser.gleam", 301).
?DOC(false).
-spec parse_value(taffy@parser@types:parser(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_value(Parser, Min_indent) ->
    case taffy@parser@types:enter_depth(Parser) of
        {error, _} ->
            {error,
                {parse_error,
                    <<"Maximum recursion depth exceeded (possible nesting bomb)"/utf8>>,
                    erlang:element(4, Parser)}};

        {ok, Parser@1} ->
            gleam@result:'try'(
                parse_value_dispatch(Parser@1, Min_indent),
                fun(_use0) ->
                    {Val, Parser@2} = _use0,
                    {ok, {Val, taffy@parser@types:exit_depth(Parser@2)}}
                end
            )
    end.

-file("src/taffy/parser.gleam", 38).
?DOC(false).
-spec parse_from(taffy@parser@types:parser()) -> {ok, taffy@value:yaml_value()} |
    {error, taffy@parser@types:parse_error()}.
parse_from(Parser) ->
    Parser@1 = taffy@parser@helpers:skip_newlines_and_comments(Parser),
    Parser@2 = case taffy@parser@helpers:current(Parser@1) of
        {some, doc_start} ->
            _pipe = taffy@parser@helpers:advance(Parser@1),
            taffy@parser@helpers:skip_newlines_and_comments(_pipe);

        _ ->
            Parser@1
    end,
    gleam@result:'try'(
        parse_value(Parser@2, 0),
        fun(_use0) ->
            {Val, Parser@3} = _use0,
            Parser@4 = taffy@parser@helpers:skip_newlines_and_comments(Parser@3),
            case taffy@parser@helpers:current(Parser@4) of
                none ->
                    {ok, Val};

                {some, eof} ->
                    {ok, Val};

                {some, doc_start} ->
                    {ok, Val};

                {some, doc_end} ->
                    {ok, Val};

                {some, Token} ->
                    {error,
                        {parse_error,
                            <<"Unexpected trailing content: "/utf8,
                                (taffy@parser@helpers:token_for_error(Token))/binary>>,
                            erlang:element(4, Parser@4)}}
            end
        end
    ).

-file("src/taffy/parser.gleam", 26).
?DOC(false).
-spec parse(list(taffy@lexer:token())) -> {ok, taffy@value:yaml_value()} |
    {error, taffy@parser@types:parse_error()}.
parse(Tokens) ->
    parse_from(new(Tokens)).

-file("src/taffy/parser.gleam", 30).
?DOC(false).
-spec parse_with(list(taffy@lexer:token()), integer(), integer()) -> {ok,
        taffy@value:yaml_value()} |
    {error, taffy@parser@types:parse_error()}.
parse_with(Tokens, Alias_budget, Max_depth) ->
    parse_from(with_limits(new(Tokens), Alias_budget, Max_depth)).

-file("src/taffy/parser.gleam", 221).
?DOC(false).
-spec parse_documents(
    taffy@parser@types:parser(),
    list(taffy@value:yaml_value())
) -> {ok, list(taffy@value:yaml_value())} |
    {error, taffy@parser@types:parse_error()}.
parse_documents(Parser, Acc) ->
    Parser@1 = taffy@parser@helpers:skip_newlines_and_comments(Parser),
    case taffy@parser@helpers:current(Parser@1) of
        none ->
            {ok, lists:reverse(Acc)};

        {some, eof} ->
            {ok, lists:reverse(Acc)};

        {some, doc_start} ->
            After_doc_start = taffy@parser@helpers:advance(Parser@1),
            gleam@result:'try'(
                check_doc_start_anchor(After_doc_start),
                fun(_) ->
                    Parser@2 = taffy@parser@helpers:skip_newlines_and_comments(
                        After_doc_start
                    ),
                    case taffy@parser@helpers:current(Parser@2) of
                        {some, doc_start} ->
                            parse_documents(
                                {parser,
                                    erlang:element(2, Parser@2),
                                    erlang:element(3, Parser@2),
                                    erlang:element(4, Parser@2),
                                    erlang:element(5, Parser@2),
                                    erlang:element(6, Parser@2),
                                    erlang:element(7, Parser@2),
                                    erlang:element(8, Parser@2),
                                    erlang:element(9, Parser@2),
                                    [],
                                    erlang:element(11, Parser@2),
                                    erlang:element(12, Parser@2),
                                    erlang:element(13, Parser@2)},
                                [null | Acc]
                            );

                        {some, doc_end} ->
                            Parser@3 = taffy@parser@helpers:advance(Parser@2),
                            gleam@result:'try'(
                                check_after_doc_end(Parser@3),
                                fun(Parser@4) ->
                                    Parser@5 = taffy@parser@helpers:skip_newlines_and_comments(
                                        Parser@4
                                    ),
                                    gleam@result:'try'(
                                        consume_directives(Parser@5),
                                        fun(Parser@6) ->
                                            parse_documents(
                                                Parser@6,
                                                [null | Acc]
                                            )
                                        end
                                    )
                                end
                            );

                        none ->
                            {ok, lists:reverse([null | Acc])};

                        {some, eof} ->
                            {ok, lists:reverse([null | Acc])};

                        _ ->
                            gleam@result:'try'(
                                parse_value(Parser@2, 0),
                                fun(_use0) ->
                                    {Val, Parser@7} = _use0,
                                    Parser@8 = taffy@parser@helpers:skip_newlines_and_comments(
                                        Parser@7
                                    ),
                                    case taffy@parser@helpers:current(Parser@8) of
                                        {some, doc_end} ->
                                            Parser@9 = taffy@parser@helpers:advance(
                                                Parser@8
                                            ),
                                            gleam@result:'try'(
                                                check_after_doc_end(Parser@9),
                                                fun(Parser@10) ->
                                                    Parser@11 = taffy@parser@helpers:skip_newlines_and_comments(
                                                        Parser@10
                                                    ),
                                                    gleam@result:'try'(
                                                        consume_directives(
                                                            Parser@11
                                                        ),
                                                        fun(Parser@12) ->
                                                            parse_documents(
                                                                Parser@12,
                                                                [Val | Acc]
                                                            )
                                                        end
                                                    )
                                                end
                                            );

                                        {some, doc_start} ->
                                            parse_documents(
                                                {parser,
                                                    erlang:element(2, Parser@8),
                                                    erlang:element(3, Parser@8),
                                                    erlang:element(4, Parser@8),
                                                    erlang:element(5, Parser@8),
                                                    erlang:element(6, Parser@8),
                                                    erlang:element(7, Parser@8),
                                                    erlang:element(8, Parser@8),
                                                    erlang:element(9, Parser@8),
                                                    [],
                                                    erlang:element(11, Parser@8),
                                                    erlang:element(12, Parser@8),
                                                    erlang:element(13, Parser@8)},
                                                [Val | Acc]
                                            );

                                        none ->
                                            parse_documents(
                                                Parser@8,
                                                [Val | Acc]
                                            );

                                        {some, eof} ->
                                            parse_documents(
                                                Parser@8,
                                                [Val | Acc]
                                            );

                                        {some, Token} ->
                                            {error,
                                                {parse_error,
                                                    <<"Unexpected trailing content: "/utf8,
                                                        (taffy@parser@helpers:token_for_error(
                                                            Token
                                                        ))/binary>>,
                                                    erlang:element(4, Parser@8)}}
                                    end
                                end
                            )
                    end
                end
            );

        {some, doc_end} ->
            Parser@13 = taffy@parser@helpers:advance(Parser@1),
            gleam@result:'try'(
                check_after_doc_end(Parser@13),
                fun(Parser@14) ->
                    Parser@15 = taffy@parser@helpers:skip_newlines_and_comments(
                        Parser@14
                    ),
                    gleam@result:'try'(
                        consume_directives(Parser@15),
                        fun(Parser@16) -> parse_documents(Parser@16, Acc) end
                    )
                end
            );

        {some, {directive, _}} ->
            gleam@result:'try'(
                consume_directives(Parser@1),
                fun(Parser@17) -> parse_documents(Parser@17, Acc) end
            );

        _ ->
            gleam@result:'try'(
                parse_value(Parser@1, 0),
                fun(_use0@1) ->
                    {Val@1, Parser@18} = _use0@1,
                    Parser@19 = taffy@parser@helpers:skip_newlines_and_comments(
                        Parser@18
                    ),
                    case taffy@parser@helpers:current(Parser@19) of
                        {some, doc_end} ->
                            Parser@20 = taffy@parser@helpers:advance(Parser@19),
                            gleam@result:'try'(
                                check_after_doc_end(Parser@20),
                                fun(Parser@21) ->
                                    Parser@22 = taffy@parser@helpers:skip_newlines_and_comments(
                                        Parser@21
                                    ),
                                    gleam@result:'try'(
                                        consume_directives(Parser@22),
                                        fun(Parser@23) ->
                                            parse_documents(
                                                Parser@23,
                                                [Val@1 | Acc]
                                            )
                                        end
                                    )
                                end
                            );

                        {some, doc_start} ->
                            parse_documents(
                                {parser,
                                    erlang:element(2, Parser@19),
                                    erlang:element(3, Parser@19),
                                    erlang:element(4, Parser@19),
                                    erlang:element(5, Parser@19),
                                    erlang:element(6, Parser@19),
                                    erlang:element(7, Parser@19),
                                    erlang:element(8, Parser@19),
                                    erlang:element(9, Parser@19),
                                    [],
                                    erlang:element(11, Parser@19),
                                    erlang:element(12, Parser@19),
                                    erlang:element(13, Parser@19)},
                                [Val@1 | Acc]
                            );

                        none ->
                            {ok, lists:reverse([Val@1 | Acc])};

                        {some, eof} ->
                            {ok, lists:reverse([Val@1 | Acc])};

                        {some, Token@1} ->
                            {error,
                                {parse_error,
                                    <<"Unexpected trailing content: "/utf8,
                                        (taffy@parser@helpers:token_for_error(
                                            Token@1
                                        ))/binary>>,
                                    erlang:element(4, Parser@19)}}
                    end
                end
            )
    end.

-file("src/taffy/parser.gleam", 72).
?DOC(false).
-spec parse_all_from(taffy@parser@types:parser()) -> {ok,
        list(taffy@value:yaml_value())} |
    {error, taffy@parser@types:parse_error()}.
parse_all_from(Parser) ->
    gleam@result:'try'(
        consume_directives(Parser),
        fun(Parser@1) -> parse_documents(Parser@1, []) end
    ).

-file("src/taffy/parser.gleam", 60).
?DOC(false).
-spec parse_all(list(taffy@lexer:token())) -> {ok,
        list(taffy@value:yaml_value())} |
    {error, taffy@parser@types:parse_error()}.
parse_all(Tokens) ->
    parse_all_from(new(Tokens)).

-file("src/taffy/parser.gleam", 64).
?DOC(false).
-spec parse_all_with(list(taffy@lexer:token()), integer(), integer()) -> {ok,
        list(taffy@value:yaml_value())} |
    {error, taffy@parser@types:parse_error()}.
parse_all_with(Tokens, Alias_budget, Max_depth) ->
    parse_all_from(with_limits(new(Tokens), Alias_budget, Max_depth)).

-file("src/taffy/parser.gleam", 372).
?DOC(false).
-spec parse_value_after_newline(taffy@parser@types:parser(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_value_after_newline(Parser, Min_indent) ->
    Parser@1 = begin
        _record = taffy@parser@helpers:advance(Parser),
        {parser,
            erlang:element(2, _record),
            erlang:element(3, _record),
            erlang:element(4, _record),
            erlang:element(5, _record),
            erlang:element(6, _record),
            false,
            erlang:element(8, _record),
            erlang:element(9, _record),
            erlang:element(10, _record),
            erlang:element(11, _record),
            erlang:element(12, _record),
            erlang:element(13, _record)}
    end,
    case Min_indent > 0 of
        true ->
            {ok, {null, Parser@1}};

        false ->
            parse_value(Parser@1, Min_indent)
    end.

-file("src/taffy/parser.gleam", 383).
?DOC(false).
-spec parse_alias_value(taffy@parser@types:parser(), binary(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_alias_value(Parser, Name, Min_indent) ->
    case taffy@parser@types:resolve_alias(Parser, Name) of
        {ok, {Alias_val, Parser@1}} ->
            case taffy@parser@helpers:current(Parser@1) of
                {some, colon} ->
                    Key = taffy@parser@scalar:value_to_key_string(Alias_val),
                    taffy@parser@block:parse_block_mapping_from_key(
                        Key,
                        taffy@parser@helpers:advance(Parser@1),
                        Min_indent,
                        fun parse_value/2
                    );

                _ ->
                    {ok, {Alias_val, Parser@1}}
            end;

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

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

-file("src/taffy/parser.gleam", 411).
?DOC(false).
-spec parse_tagged_value(taffy@parser@types:parser(), binary(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_tagged_value(Parser, Tag, Min_indent) ->
    gleam@result:'try'(
        validate_tag_handle(Tag, Parser),
        fun(_) ->
            Parser@1 = taffy@parser@helpers:advance(Parser),
            Is_str_tag = (Tag =:= <<"!!str"/utf8>>) orelse gleam_stdlib:contains_string(
                Tag,
                <<"tag:yaml.org,2002:str"/utf8>>
            ),
            Is_non_specific = Tag =:= <<"!"/utf8>>,
            case {taffy@parser@helpers:current(Parser@1),
                Is_str_tag,
                Is_non_specific} of
                {{some, eof}, true, _} ->
                    {ok, {{string, <<""/utf8>>}, Parser@1}};

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

                {{some, newline}, true, _} ->
                    After_newline = taffy@parser@helpers:advance(Parser@1),
                    case taffy@parser@helpers:current(After_newline) of
                        {some, eof} ->
                            {ok, {{string, <<""/utf8>>}, Parser@1}};

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

                        {some, doc_start} ->
                            {ok, {{string, <<""/utf8>>}, Parser@1}};

                        {some, doc_end} ->
                            {ok, {{string, <<""/utf8>>}, Parser@1}};

                        {some, dash} ->
                            {ok, {{string, <<""/utf8>>}, Parser@1}};

                        _ ->
                            parse_value(Parser@1, Min_indent)
                    end;

                {{some, {plain, S}}, _, true} ->
                    {ok,
                        {{string, gleam@string:trim(S)},
                            taffy@parser@helpers:advance(Parser@1)}};

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

-file("src/taffy/parser.gleam", 438).
?DOC(false).
-spec parse_flow_sequence_value(taffy@parser@types:parser(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_sequence_value(Parser, Min_indent) ->
    Parser@1 = begin
        _record = taffy@parser@helpers:advance(Parser),
        {parser,
            erlang:element(2, _record),
            erlang:element(3, _record),
            erlang:element(4, _record),
            erlang:element(5, _record),
            erlang:element(6, _record),
            erlang:element(7, _record),
            Min_indent,
            false,
            erlang:element(10, _record),
            erlang:element(11, _record),
            erlang:element(12, _record),
            erlang:element(13, _record)}
    end,
    gleam@result:'try'(
        taffy@parser@flow:parse_flow_sequence(Parser@1),
        fun(_use0) ->
            {Seq_val, Parser@2} = _use0,
            Was_multiline = erlang:element(9, Parser@2),
            case taffy@parser@helpers:current(Parser@2) of
                {some, colon} ->
                    case Was_multiline of
                        true ->
                            {error,
                                {parse_error,
                                    <<"Multiline flow sequence cannot be used as implicit mapping key"/utf8>>,
                                    erlang:element(4, Parser@2)}};

                        false ->
                            Key = taffy@parser@scalar:value_to_key_string(
                                Seq_val
                            ),
                            taffy@parser@block:parse_block_mapping_from_key(
                                Key,
                                taffy@parser@helpers:advance(Parser@2),
                                Min_indent,
                                fun parse_value/2
                            )
                    end;

                {some, {plain, _}} ->
                    {error,
                        {parse_error,
                            <<"Invalid content after flow sequence"/utf8>>,
                            erlang:element(4, Parser@2)}};

                {some, {single_quoted, _}} ->
                    {error,
                        {parse_error,
                            <<"Invalid content after flow sequence"/utf8>>,
                            erlang:element(4, Parser@2)}};

                {some, {double_quoted, _}} ->
                    {error,
                        {parse_error,
                            <<"Invalid content after flow sequence"/utf8>>,
                            erlang:element(4, Parser@2)}};

                {some, dash} ->
                    {error,
                        {parse_error,
                            <<"Invalid content after flow sequence"/utf8>>,
                            erlang:element(4, Parser@2)}};

                _ ->
                    {ok, {Seq_val, Parser@2}}
            end
        end
    ).

-file("src/taffy/parser.gleam", 477).
?DOC(false).
-spec parse_flow_mapping_value(taffy@parser@types:parser(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_flow_mapping_value(Parser, Min_indent) ->
    Parser@1 = begin
        _record = taffy@parser@helpers:advance(Parser),
        {parser,
            erlang:element(2, _record),
            erlang:element(3, _record),
            erlang:element(4, _record),
            erlang:element(5, _record),
            erlang:element(6, _record),
            erlang:element(7, _record),
            Min_indent,
            erlang:element(9, _record),
            erlang:element(10, _record),
            erlang:element(11, _record),
            erlang:element(12, _record),
            erlang:element(13, _record)}
    end,
    gleam@result:'try'(
        taffy@parser@flow:parse_flow_mapping(Parser@1),
        fun(_use0) ->
            {Map_val, Parser@2} = _use0,
            case taffy@parser@helpers:current(Parser@2) of
                {some, colon} ->
                    Key = taffy@parser@scalar:value_to_key_string(Map_val),
                    taffy@parser@block:parse_block_mapping_from_key(
                        Key,
                        taffy@parser@helpers:advance(Parser@2),
                        Min_indent,
                        fun parse_value/2
                    );

                {some, {plain, _}} ->
                    {error,
                        {parse_error,
                            <<"Invalid content after flow mapping"/utf8>>,
                            erlang:element(4, Parser@2)}};

                {some, {single_quoted, _}} ->
                    {error,
                        {parse_error,
                            <<"Invalid content after flow mapping"/utf8>>,
                            erlang:element(4, Parser@2)}};

                {some, {double_quoted, _}} ->
                    {error,
                        {parse_error,
                            <<"Invalid content after flow mapping"/utf8>>,
                            erlang:element(4, Parser@2)}};

                {some, dash} ->
                    {error,
                        {parse_error,
                            <<"Invalid content after flow mapping"/utf8>>,
                            erlang:element(4, Parser@2)}};

                _ ->
                    {ok, {Map_val, Parser@2}}
            end
        end
    ).

-file("src/taffy/parser.gleam", 502).
?DOC(false).
-spec parse_colon_value(taffy@parser@types:parser(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_colon_value(Parser, Min_indent) ->
    After_colon = taffy@parser@helpers:advance(Parser),
    case taffy@parser@helpers:current(After_colon) of
        {some, {plain, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, {single_quoted, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, {double_quoted, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, {anchor, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, {alias, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, dash} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, bracket_open} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, brace_open} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, newline} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, {indent, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, {comment, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, eof} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        none ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, colon} ->
            {Rest, Parser@1} = collect_plain_scalar_from_colon(After_colon),
            {ok,
                {taffy@parser@scalar:parse_scalar(<<":"/utf8, Rest/binary>>),
                    Parser@1}};

        {some, comma} ->
            {Rest, Parser@1} = collect_plain_scalar_from_colon(After_colon),
            {ok,
                {taffy@parser@scalar:parse_scalar(<<":"/utf8, Rest/binary>>),
                    Parser@1}};

        {some, bracket_close} ->
            {Rest, Parser@1} = collect_plain_scalar_from_colon(After_colon),
            {ok,
                {taffy@parser@scalar:parse_scalar(<<":"/utf8, Rest/binary>>),
                    Parser@1}};

        {some, brace_close} ->
            {Rest, Parser@1} = collect_plain_scalar_from_colon(After_colon),
            {ok,
                {taffy@parser@scalar:parse_scalar(<<":"/utf8, Rest/binary>>),
                    Parser@1}};

        {some, {tag, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, question} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, {literal, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, {folded, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, doc_start} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, doc_end} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            );

        {some, {directive, _}} ->
            taffy@parser@block:parse_block_mapping_from_key(
                <<""/utf8>>,
                After_colon,
                Min_indent,
                fun parse_value/2
            )
    end.

-file("src/taffy/parser.gleam", 625).
?DOC(false).
-spec parse_quoted_value(taffy@parser@types:parser(), binary(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_quoted_value(Parser, S, Min_indent) ->
    Parser@1 = taffy@parser@helpers:advance(Parser),
    case taffy@parser@helpers:current(Parser@1) of
        {some, colon} ->
            After_colon = taffy@parser@helpers:advance(Parser@1),
            case erlang:element(7, Parser@1) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser@1)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        S,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {plain, _}} ->
            {error,
                {parse_error,
                    <<"Invalid content after quoted value"/utf8>>,
                    erlang:element(4, Parser@1)}};

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

-file("src/taffy/parser.gleam", 1012).
?DOC(false).
-spec parse_anchored_scalar_or_key(
    taffy@parser@types:parser(),
    binary(),
    binary(),
    integer(),
    fun((binary()) -> taffy@value:yaml_value())
) -> {ok, {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_anchored_scalar_or_key(Parser, Anchor_name, S, Min_indent, To_value) ->
    After_scalar = taffy@parser@helpers:advance(Parser),
    case taffy@parser@helpers:current(After_scalar) of
        {some, colon} ->
            Parser@1 = taffy@parser@types:register_anchor(
                After_scalar,
                Anchor_name,
                {string, S}
            ),
            taffy@parser@block:parse_block_mapping_from_key(
                S,
                taffy@parser@helpers:advance(Parser@1),
                Min_indent,
                fun parse_value/2
            );

        _ ->
            Val = To_value(S),
            Parser@2 = taffy@parser@types:register_anchor(
                taffy@parser@helpers:advance(Parser),
                Anchor_name,
                Val
            ),
            {ok, {Val, Parser@2}}
    end.

-file("src/taffy/parser.gleam", 977).
?DOC(false).
-spec parse_anchored_value(taffy@parser@types:parser(), binary(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_anchored_value(Parser, Name, Min_indent) ->
    case taffy@parser@helpers:current(Parser) of
        {some, {anchor, _}} ->
            {error,
                {parse_error,
                    <<"A node can only have one anchor"/utf8>>,
                    erlang:element(4, Parser)}};

        {some, {alias, _}} ->
            {error,
                {parse_error,
                    <<"Cannot place an anchor on an alias"/utf8>>,
                    erlang:element(4, Parser)}};

        {some, {plain, S}} ->
            parse_anchored_scalar_or_key(
                Parser,
                Name,
                S,
                Min_indent,
                fun taffy@parser@scalar:parse_scalar/1
            );

        {some, {single_quoted, S@1}} ->
            parse_anchored_scalar_or_key(
                Parser,
                Name,
                S@1,
                Min_indent,
                fun(V) -> {string, V} end
            );

        {some, {double_quoted, S@1}} ->
            parse_anchored_scalar_or_key(
                Parser,
                Name,
                S@1,
                Min_indent,
                fun(V) -> {string, V} end
            );

        {some, dash} ->
            {error,
                {parse_error,
                    <<"Block sequence not allowed on same line as anchor"/utf8>>,
                    erlang:element(4, Parser)}};

        _ ->
            gleam@result:'try'(
                parse_value(Parser, Min_indent),
                fun(_use0) ->
                    {Val, Parser@1} = _use0,
                    Parser@2 = taffy@parser@types:register_anchor(
                        Parser@1,
                        Name,
                        Val
                    ),
                    {ok, {Val, Parser@2}}
                end
            )
    end.

-file("src/taffy/parser.gleam", 866).
?DOC(false).
-spec collect_after_indent(
    taffy@parser@types:parser(),
    binary(),
    integer(),
    integer()
) -> {binary(), taffy@parser@types:parser()}.
collect_after_indent(Parser, Acc, Min_indent, N) ->
    After_indent = taffy@parser@helpers:advance(Parser),
    case taffy@parser@helpers:current(After_indent) of
        {some, dash} ->
            case should_absorb_dash_in_scalar(
                erlang:element(6, Parser),
                N,
                Min_indent
            ) of
                true ->
                    collect_block_plain_value(
                        taffy@parser@helpers:advance(After_indent),
                        append_continuation(Acc, <<"-"/utf8>>),
                        Min_indent
                    );

                false ->
                    {Acc, Parser}
            end;

        {some, question} ->
            {Acc, Parser};

        {some, colon} ->
            {Acc, Parser};

        {some, {comment, _}} ->
            {Acc, Parser};

        {some, {indent, M}} when M >= Min_indent ->
            collect_block_plain_value(
                After_indent,
                <<Acc/binary, "\n"/utf8>>,
                Min_indent
            );

        {some, {plain, S}} ->
            case is_mapping_key(After_indent) of
                true ->
                    {Acc, Parser};

                false ->
                    collect_block_plain_value(
                        taffy@parser@helpers:advance(After_indent),
                        append_continuation(Acc, S),
                        Min_indent
                    )
            end;

        {some, Token} ->
            case token_as_scalar_fragment(Token) of
                {some, Fragment} ->
                    collect_block_plain_value(
                        taffy@parser@helpers:advance(After_indent),
                        append_continuation(Acc, Fragment),
                        Min_indent
                    );

                none ->
                    {Acc, Parser}
            end;

        none ->
            {Acc, Parser}
    end.

-file("src/taffy/parser.gleam", 828).
?DOC(false).
-spec collect_block_plain_value(
    taffy@parser@types:parser(),
    binary(),
    integer()
) -> {binary(), taffy@parser@types:parser()}.
collect_block_plain_value(Parser, Acc, Min_indent) ->
    case taffy@parser@helpers:current(Parser) of
        {some, comma} ->
            collect_block_plain_value(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, ","/utf8>>,
                Min_indent
            );

        {some, bracket_open} ->
            collect_block_plain_value(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, "["/utf8>>,
                Min_indent
            );

        {some, bracket_close} ->
            collect_block_plain_value(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, "]"/utf8>>,
                Min_indent
            );

        {some, brace_open} ->
            collect_block_plain_value(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, "{"/utf8>>,
                Min_indent
            );

        {some, brace_close} ->
            collect_block_plain_value(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, "}"/utf8>>,
                Min_indent
            );

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

        {some, {plain, S}} ->
            collect_block_plain_value(
                taffy@parser@helpers:advance(Parser),
                <<<<Acc/binary, " "/utf8>>/binary, S/binary>>,
                Min_indent
            );

        {some, {tag, S@1}} ->
            collect_block_plain_value(
                taffy@parser@helpers:advance(Parser),
                <<<<Acc/binary, " "/utf8>>/binary, S@1/binary>>,
                Min_indent
            );

        {some, {anchor, S@2}} ->
            collect_block_plain_value(
                taffy@parser@helpers:advance(Parser),
                <<<<Acc/binary, " &"/utf8>>/binary, S@2/binary>>,
                Min_indent
            );

        {some, newline} ->
            After_newline = taffy@parser@helpers:advance(Parser),
            case taffy@parser@helpers:current(After_newline) of
                {some, {indent, _}} ->
                    check_multiline_continuation(
                        After_newline,
                        <<Acc/binary, "\n"/utf8>>,
                        Min_indent
                    );

                _ ->
                    check_multiline_continuation(After_newline, Acc, Min_indent)
            end;

        {some, {indent, N}} when N >= Min_indent ->
            collect_after_indent(Parser, Acc, Min_indent, N);

        _ ->
            {Acc, Parser}
    end.

-file("src/taffy/parser.gleam", 577).
?DOC(false).
-spec parse_plain_after_colon(taffy@parser@types:parser(), binary(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_plain_after_colon(Parser, Full_key, Min_indent) ->
    After_colon = taffy@parser@helpers:advance(Parser),
    case taffy@parser@helpers:current(After_colon) of
        {some, {plain, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {single_quoted, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {double_quoted, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, newline} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {indent, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, eof} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {comment, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {anchor, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {alias, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {tag, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, dash} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, question} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {literal, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, {folded, _}} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, bracket_open} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        {some, brace_open} ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        none ->
            case erlang:element(7, Parser) andalso is_inline_value_token(
                taffy@parser@helpers:current(After_colon)
            ) of
                true ->
                    {error,
                        {parse_error,
                            <<"Implicit mapping not allowed as inline mapping value"/utf8>>,
                            erlang:element(4, Parser)}};

                false ->
                    taffy@parser@block:parse_block_mapping_from_key(
                        Full_key,
                        After_colon,
                        Min_indent,
                        fun parse_value/2
                    )
            end;

        _ ->
            {Rest, Parser@1} = collect_block_plain_value(
                After_colon,
                <<Full_key/binary, ":"/utf8>>,
                Min_indent
            ),
            {ok, {taffy@parser@scalar:parse_scalar(Rest), Parser@1}}
    end.

-file("src/taffy/parser.gleam", 940).
?DOC(false).
-spec continue_after_continuation_indent(
    taffy@parser@types:parser(),
    binary(),
    integer()
) -> {binary(), taffy@parser@types:parser()}.
continue_after_continuation_indent(Parser, Acc, Min_indent) ->
    After_indent = taffy@parser@helpers:advance(Parser),
    case taffy@parser@helpers:current(After_indent) of
        {some, newline} ->
            check_multiline_continuation(
                taffy@parser@helpers:advance(After_indent),
                <<Acc/binary, "\n"/utf8>>,
                Min_indent
            );

        {some, {plain, S}} ->
            case is_mapping_key(After_indent) of
                true ->
                    {Acc, taffy@parser@helpers:backtrack(Parser)};

                false ->
                    collect_block_plain_value(
                        taffy@parser@helpers:advance(After_indent),
                        append_continuation(Acc, S),
                        Min_indent
                    )
            end;

        {some, Token} ->
            case token_as_scalar_fragment(Token) of
                {some, Fragment} ->
                    collect_block_plain_value(
                        taffy@parser@helpers:advance(After_indent),
                        append_continuation(Acc, Fragment),
                        Min_indent
                    );

                none ->
                    {Acc, taffy@parser@helpers:backtrack(Parser)}
            end;

        none ->
            {Acc, taffy@parser@helpers:backtrack(Parser)}
    end.

-file("src/taffy/parser.gleam", 916).
?DOC(false).
-spec check_multiline_continuation(
    taffy@parser@types:parser(),
    binary(),
    integer()
) -> {binary(), taffy@parser@types:parser()}.
check_multiline_continuation(Parser, Acc, Min_indent) ->
    case taffy@parser@helpers:current(Parser) of
        {some, newline} ->
            check_multiline_continuation(
                taffy@parser@helpers:advance(Parser),
                <<Acc/binary, "\n"/utf8>>,
                Min_indent
            );

        {some, {indent, N}} when N >= Min_indent ->
            continue_after_continuation_indent(Parser, Acc, Min_indent);

        {some, {plain, S}} when Min_indent =:= 0 ->
            case is_mapping_key(Parser) of
                true ->
                    {Acc, taffy@parser@helpers:backtrack(Parser)};

                false ->
                    collect_block_plain_value(
                        taffy@parser@helpers:advance(Parser),
                        append_continuation(Acc, S),
                        Min_indent
                    )
            end;

        _ ->
            {Acc, taffy@parser@helpers:backtrack(Parser)}
    end.

-file("src/taffy/parser.gleam", 550).
?DOC(false).
-spec parse_plain_value(taffy@parser@types:parser(), binary(), integer()) -> {ok,
        {taffy@value:yaml_value(), taffy@parser@types:parser()}} |
    {error, taffy@parser@types:parse_error()}.
parse_plain_value(Parser, S, Min_indent) ->
    {Full_key, Parser@1} = collect_block_plain_key(
        taffy@parser@helpers:advance(Parser),
        S
    ),
    case taffy@parser@helpers:current(Parser@1) of
        {some, colon} ->
            parse_plain_after_colon(Parser@1, Full_key, Min_indent);

        {some, newline} ->
            After_newline = taffy@parser@helpers:advance(Parser@1),
            Acc = case taffy@parser@helpers:current(After_newline) of
                {some, {indent, _}} ->
                    <<Full_key/binary, "\n"/utf8>>;

                _ ->
                    Full_key
            end,
            {Full_value, Parser@2} = check_multiline_continuation(
                After_newline,
                Acc,
                Min_indent
            ),
            {ok, {taffy@parser@scalar:parse_scalar(Full_value), Parser@2}};

        {some, {indent, N}} when N >= Min_indent ->
            {Full_value@1, Parser@3} = collect_block_plain_value(
                Parser@1,
                Full_key,
                Min_indent
            ),
            {ok, {taffy@parser@scalar:parse_scalar(Full_value@1), Parser@3}};

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