-module(molt@internal@emitter).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/molt/internal/emitter.gleam").
-export([normalize/1, emit_versioned/2, emit/1]).
-export_type([emit_state/0]).

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

?MODULEDOC(false).

-type emit_state() :: {emit_state,
        gleam@string_tree:string_tree(),
        integer(),
        integer(),
        boolean(),
        boolean()}.

-file("src/molt/internal/emitter.gleam", 812).
?DOC(false).
-spec last_ends_with_newline(list(greenwood:element(molt@types:toml_kind()))) -> boolean().
last_ends_with_newline(Children) ->
    case gleam@list:last(Children) of
        {ok, {token_element, {token, newline, _}}} ->
            true;

        {ok, {node_element, Node}} ->
            last_ends_with_newline(erlang:element(3, Node));

        _ ->
            false
    end.

-file("src/molt/internal/emitter.gleam", 805).
?DOC(false).
-spec ensure_trailing_newline(list(greenwood:element(molt@types:toml_kind()))) -> list(greenwood:element(molt@types:toml_kind())).
ensure_trailing_newline(Children) ->
    gleam@bool:guard(
        last_ends_with_newline(Children),
        Children,
        fun() ->
            lists:append(
                Children,
                [{token_element, {token, newline, <<"\n"/utf8>>}}]
            )
        end
    ).

-file("src/molt/internal/emitter.gleam", 757).
?DOC(false).
-spec find_trailing_comment_text(list(greenwood:token(molt@types:toml_kind()))) -> gleam@option:option(binary()).
find_trailing_comment_text(Tokens) ->
    _pipe = gleam@list:find_map(Tokens, fun(T) -> case erlang:element(2, T) of
                comment ->
                    {ok, erlang:element(3, T)};

                _ ->
                    {error, nil}
            end end),
    gleam@option:from_result(_pipe).

-file("src/molt/internal/emitter.gleam", 722).
?DOC(false).
-spec normalize_trivia(greenwood:node_(molt@types:toml_kind())) -> greenwood:trivia(molt@types:toml_kind()).
normalize_trivia(Node) ->
    case erlang:element(4, Node) of
        bare ->
            bare;

        {trivia, Leading, Trailing} ->
            Comments = begin
                _pipe = gleam@list:filter_map(
                    Leading,
                    fun(T) -> case erlang:element(2, T) of
                            comment ->
                                {ok,
                                    [{token, comment, erlang:element(3, T)},
                                        {token, newline, <<"\n"/utf8>>}]};

                            _ ->
                                {error, nil}
                        end end
                ),
                lists:append(_pipe)
            end,
            Trailing@1 = case find_trailing_comment_text(Trailing) of
                {some, Text} ->
                    [{token, whitespace, <<" "/utf8>>}, {token, comment, Text}];

                none ->
                    []
            end,
            case {Comments, Trailing@1} of
                {[], []} ->
                    bare;

                {_, _} ->
                    {trivia, Comments, Trailing@1}
            end
    end.

-file("src/molt/internal/emitter.gleam", 797).
?DOC(false).
-spec extract_inline_comment(list(greenwood:element(molt@types:toml_kind()))) -> binary().
extract_inline_comment(Children) ->
    case Children of
        [] ->
            <<""/utf8>>;

        [{token_element, {token, comment, Text}} | _] ->
            Text;

        [_ | Rest] ->
            extract_inline_comment(Rest)
    end.

-file("src/molt/internal/emitter.gleam", 707).
?DOC(false).
-spec interpose_separated(list(greenwood:element(molt@types:toml_kind()))) -> list(greenwood:element(molt@types:toml_kind())).
interpose_separated(Elements) ->
    case Elements of
        [] ->
            [];

        [Single] ->
            [Single];

        [Head | Rest] ->
            [Head,
                {token_element, {token, comma, <<","/utf8>>}},
                {token_element, {token, whitespace, <<" "/utf8>>}} |
                interpose_separated(Rest)]
    end.

-file("src/molt/internal/emitter.gleam", 594).
?DOC(false).
-spec trivia_has_comment(greenwood:trivia(molt@types:toml_kind())) -> boolean().
trivia_has_comment(Trivia) ->
    case Trivia of
        bare ->
            false;

        {trivia, Leading, Trailing} ->
            gleam@list:any(
                lists:append(Leading, Trailing),
                fun(T) -> erlang:element(2, T) =:= comment end
            )
    end.

-file("src/molt/internal/emitter.gleam", 583).
?DOC(false).
-spec contains_comment(greenwood:node_(molt@types:toml_kind())) -> boolean().
contains_comment(Node) ->
    trivia_has_comment(erlang:element(4, Node)) orelse gleam@list:any(
        erlang:element(3, Node),
        fun(El) -> case El of
                {token_element, {token, comment, _}} ->
                    true;

                {token_element, _} ->
                    false;

                {node_element, Child} ->
                    contains_comment(Child)
            end end
    ).

-file("src/molt/internal/emitter.gleam", 634).
?DOC(false).
-spec canonical_array_element(
    greenwood:element(molt@types:toml_kind()),
    boolean()
) -> greenwood:node_(molt@types:toml_kind()).
canonical_array_element(Value, Last) ->
    Children = case Last of
        true ->
            [Value];

        false ->
            [Value,
                {token_element, {token, comma, <<","/utf8>>}},
                {token_element, {token, whitespace, <<" "/utf8>>}}]
    end,
    {node, array_element, Children, bare}.

-file("src/molt/internal/emitter.gleam", 679).
?DOC(false).
-spec normalize_inline_kv(greenwood:node_(molt@types:toml_kind())) -> greenwood:element(molt@types:toml_kind()).
normalize_inline_kv(Kv) ->
    {Key_side, _} = molt@internal@cst@elements:split_at_equals(
        erlang:element(3, Kv)
    ),
    Key_elements = gleam@list:filter(Key_side, fun(El) -> case El of
                {token_element, {token, whitespace, _}} ->
                    false;

                _ ->
                    true
            end end),
    Value_part = begin
        _pipe = molt@internal@cst@elements:value_tokens(erlang:element(3, Kv)),
        _pipe@1 = molt@internal@cst@elements:find_first_value(_pipe),
        _pipe@2 = gleam@option:map(
            _pipe@1,
            fun(V) -> [normalize_value_el(V)] end
        ),
        gleam@option:unwrap(_pipe@2, [])
    end,
    Children = lists:append(
        [Key_elements,
            [{token_element, {token, whitespace, <<" "/utf8>>}},
                {token_element, {token, equals, <<""/utf8>>}},
                {token_element, {token, whitespace, <<" "/utf8>>}}],
            Value_part]
    ),
    {node_element, {node, erlang:element(2, Kv), Children, bare}}.

-file("src/molt/internal/emitter.gleam", 651).
?DOC(false).
-spec canonical_inline_table(greenwood:node_(molt@types:toml_kind())) -> greenwood:node_(molt@types:toml_kind()).
canonical_inline_table(Node) ->
    Entries = begin
        _pipe = molt@internal@cst@elements:extract_inline_entries(Node),
        gleam@list:map(_pipe, fun normalize_inline_kv/1)
    end,
    Children = case Entries of
        [] ->
            [{token_element, {token, left_brace, <<"{"/utf8>>}},
                {token_element, {token, right_brace, <<"}"/utf8>>}}];

        _ ->
            lists:append(
                [[{token_element, {token, left_brace, <<"{"/utf8>>}},
                        {token_element, {token, whitespace, <<" "/utf8>>}}],
                    interpose_separated(Entries),
                    [{token_element, {token, whitespace, <<" "/utf8>>}},
                        {token_element, {token, right_brace, <<"}"/utf8>>}}]]
            )
    end,
    {node, erlang:element(2, Node), Children, bare}.

-file("src/molt/internal/emitter.gleam", 608).
?DOC(false).
-spec canonical_array(greenwood:node_(molt@types:toml_kind())) -> greenwood:node_(molt@types:toml_kind()).
canonical_array(Node) ->
    Values = begin
        _pipe = molt@internal@cst@elements:extract_array_items(Node),
        gleam@list:filter_map(
            _pipe,
            fun(Item) ->
                case molt@internal@cst@elements:find_first_value(
                    erlang:element(3, Item)
                ) of
                    {some, V} ->
                        {ok, normalize_value_el(V)};

                    none ->
                        {error, nil}
                end
            end
        )
    end,
    Item_count = erlang:length(Values),
    Item_elements = gleam@list:index_map(
        Values,
        fun(V@1, I) ->
            Last = I =:= (Item_count - 1),
            {node_element, canonical_array_element(V@1, Last)}
        end
    ),
    Children = lists:append(
        [[{token_element, {token, left_bracket, <<"["/utf8>>}}],
            Item_elements,
            [{token_element, {token, right_bracket, <<"]"/utf8>>}}]]
    ),
    {node, erlang:element(2, Node), Children, bare}.

-file("src/molt/internal/emitter.gleam", 559).
?DOC(false).
-spec normalize_value_el(greenwood:element(molt@types:toml_kind())) -> greenwood:element(molt@types:toml_kind()).
normalize_value_el(El) ->
    case El of
        {node_element, N} ->
            case erlang:element(2, N) of
                array ->
                    case contains_comment(N) of
                        true ->
                            El;

                        false ->
                            {node_element, canonical_array(N)}
                    end;

                inline_table ->
                    case contains_comment(N) of
                        true ->
                            El;

                        false ->
                            {node_element, canonical_inline_table(N)}
                    end;

                _ ->
                    El
            end;

        _ ->
            El
    end.

-file("src/molt/internal/emitter.gleam", 490).
?DOC(false).
-spec normalize_kv_node(greenwood:node_(molt@types:toml_kind())) -> greenwood:node_(molt@types:toml_kind()).
normalize_kv_node(Node) ->
    {Key_side, _} = molt@internal@cst@elements:split_at_equals(
        erlang:element(3, Node)
    ),
    Key_elements = gleam@list:filter(Key_side, fun(El) -> case El of
                {token_element, {token, whitespace, _}} ->
                    false;

                _ ->
                    true
            end end),
    Value_el = begin
        _pipe = molt@internal@cst@elements:value_tokens(erlang:element(3, Node)),
        _pipe@1 = molt@internal@cst@elements:find_first_value(_pipe),
        gleam@option:map(_pipe@1, fun normalize_value_el/1)
    end,
    Comment = extract_inline_comment(erlang:element(3, Node)),
    Value_part = case {Value_el, Comment} of
        {{some, El@1}, <<""/utf8>>} ->
            [El@1, {token_element, {token, newline, <<"\n"/utf8>>}}];

        {{some, El@2}, C} ->
            [El@2,
                {token_element, {token, whitespace, <<" "/utf8>>}},
                {token_element, {token, comment, C}},
                {token_element, {token, newline, <<"\n"/utf8>>}}];

        {none, _} ->
            [{token_element, {token, newline, <<"\n"/utf8>>}}]
    end,
    Children = lists:append(
        [Key_elements,
            [{token_element, {token, whitespace, <<" "/utf8>>}},
                {token_element, {token, equals, <<""/utf8>>}},
                {token_element, {token, whitespace, <<" "/utf8>>}}],
            Value_part]
    ),
    {node, erlang:element(2, Node), Children, normalize_trivia(Node)}.

-file("src/molt/internal/emitter.gleam", 786).
?DOC(false).
-spec normalize_body(list(greenwood:element(molt@types:toml_kind()))) -> list(greenwood:element(molt@types:toml_kind())).
normalize_body(Children) ->
    gleam@list:filter_map(Children, fun(El) -> case El of
                {node_element, N} when erlang:element(2, N) =:= key_value ->
                    {ok, {node_element, normalize_kv_node(N)}};

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

-file("src/molt/internal/emitter.gleam", 769).
?DOC(false).
-spec extract_header_tokens(list(greenwood:element(molt@types:toml_kind()))) -> list(greenwood:element(molt@types:toml_kind())).
extract_header_tokens(Children) ->
    gleam@list:filter_map(Children, fun(El) -> case El of
                {token_element, {token, left_bracket, _}} ->
                    {ok, El};

                {token_element, {token, right_bracket, _}} ->
                    {ok, El};

                {token_element, {token, dot, _}} ->
                    {ok, El};

                {token_element, {token, bare_key, _}} ->
                    {ok, El};

                {token_element, {token, basic_string, _}} ->
                    {ok, El};

                {token_element, {token, literal_string, _}} ->
                    {ok, El};

                {token_element, {token, integer, _}} ->
                    {ok, El};

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

-file("src/molt/internal/emitter.gleam", 532).
?DOC(false).
-spec normalize_postscript(
    greenwood:node_(molt@types:toml_kind()),
    boolean(),
    list(greenwood:element(molt@types:toml_kind()))
) -> list(greenwood:element(molt@types:toml_kind())).
normalize_postscript(Node, First, Rest) ->
    case normalize_trivia(Node) of
        bare ->
            normalize_top_level(Rest, First);

        {trivia, Leading, Trailing} ->
            Leading@1 = case First of
                true ->
                    Leading;

                false ->
                    [{token, newline, <<"\n"/utf8>>} | Leading]
            end,
            [{node_element,
                    {node,
                        erlang:element(2, Node),
                        [],
                        {trivia, Leading@1, Trailing}}} |
                normalize_top_level(Rest, First)]
    end.

-file("src/molt/internal/emitter.gleam", 451).
?DOC(false).
-spec normalize_table_node(
    greenwood:node_(molt@types:toml_kind()),
    boolean(),
    list(greenwood:element(molt@types:toml_kind()))
) -> list(greenwood:element(molt@types:toml_kind())).
normalize_table_node(Node, First, Rest) ->
    Sep = case First of
        true ->
            [];

        false ->
            [{token_element, {token, newline, <<"\n"/utf8>>}}]
    end,
    Header_tokens = extract_header_tokens(erlang:element(3, Node)),
    Comment = extract_inline_comment(erlang:element(3, Node)),
    Body = normalize_body(erlang:element(3, Node)),
    Header_line = case Comment of
        <<""/utf8>> ->
            lists:append(
                [Header_tokens,
                    [{token_element, {token, newline, <<"\n"/utf8>>}}]]
            );

        C ->
            lists:append(
                [Header_tokens,
                    [{token_element, {token, whitespace, <<" "/utf8>>}},
                        {token_element, {token, comment, C}},
                        {token_element, {token, newline, <<"\n"/utf8>>}}]]
            )
    end,
    Children = lists:append([Header_line, Body]),
    Trivia = normalize_trivia(Node),
    Normalized = {node, erlang:element(2, Node), Children, Trivia},
    lists:append(
        [Sep, [{node_element, Normalized}], normalize_top_level(Rest, false)]
    ).

-file("src/molt/internal/emitter.gleam", 424).
?DOC(false).
-spec normalize_top_level(
    list(greenwood:element(molt@types:toml_kind())),
    boolean()
) -> list(greenwood:element(molt@types:toml_kind())).
normalize_top_level(Children, First) ->
    case Children of
        [] ->
            [];

        [El | Rest] ->
            case El of
                {node_element, N} when (erlang:element(2, N) =:= table) orelse (erlang:element(
                    2,
                    N
                ) =:= array_of_tables) ->
                    normalize_table_node(N, First, Rest);

                {node_element, N@1} when erlang:element(2, N@1) =:= key_value ->
                    [{node_element, normalize_kv_node(N@1)} |
                        normalize_top_level(Rest, false)];

                {node_element, N@2} when erlang:element(2, N@2) =:= post_script ->
                    normalize_postscript(N@2, First, Rest);

                {token_element, {token, comment, _}} ->
                    [El,
                        {token_element, {token, newline, <<"\n"/utf8>>}} |
                        normalize_top_level(Rest, First)];

                _ ->
                    normalize_top_level(Rest, First)
            end
    end.

-file("src/molt/internal/emitter.gleam", 44).
?DOC(false).
-spec normalize(greenwood:node_(molt@types:toml_kind())) -> greenwood:node_(molt@types:toml_kind()).
normalize(Node) ->
    Children = normalize_top_level(erlang:element(3, Node), true),
    Children@1 = ensure_trailing_newline(Children),
    {node, erlang:element(2, Node), Children@1, erlang:element(4, Node)}.

-file("src/molt/internal/emitter.gleam", 328).
?DOC(false).
-spec emit_token_common(
    gleam@string_tree:string_tree(),
    greenwood:token(molt@types:toml_kind())
) -> gleam@string_tree:string_tree().
emit_token_common(Tree, Tok) ->
    case erlang:element(2, Tok) of
        equals ->
            gleam@string_tree:append(Tree, <<"="/utf8>>);

        dot ->
            gleam@string_tree:append(Tree, <<"."/utf8>>);

        comma ->
            gleam@string_tree:append(Tree, <<","/utf8>>);

        left_bracket ->
            gleam@string_tree:append(Tree, <<"["/utf8>>);

        right_bracket ->
            gleam@string_tree:append(Tree, <<"]"/utf8>>);

        left_brace ->
            gleam@string_tree:append(Tree, <<"{"/utf8>>);

        right_brace ->
            gleam@string_tree:append(Tree, <<"}"/utf8>>);

        bool_true ->
            gleam@string_tree:append(Tree, <<"true"/utf8>>);

        bool_false ->
            gleam@string_tree:append(Tree, <<"false"/utf8>>);

        inf ->
            gleam@string_tree:append(Tree, <<"inf"/utf8>>);

        pos_inf ->
            gleam@string_tree:append(Tree, <<"+inf"/utf8>>);

        neg_inf ->
            gleam@string_tree:append(Tree, <<"-inf"/utf8>>);

        na_n ->
            gleam@string_tree:append(Tree, <<"nan"/utf8>>);

        pos_na_n ->
            gleam@string_tree:append(Tree, <<"+nan"/utf8>>);

        neg_na_n ->
            gleam@string_tree:append(Tree, <<"-nan"/utf8>>);

        literal_string ->
            gleam@string_tree:append(
                Tree,
                <<<<"'"/utf8, (erlang:element(3, Tok))/binary>>/binary,
                    "'"/utf8>>
            );

        multiline_literal_string ->
            gleam@string_tree:append(
                Tree,
                <<<<"'''"/utf8, (erlang:element(3, Tok))/binary>>/binary,
                    "'''"/utf8>>
            );

        multiline_literal_string_nl ->
            gleam@string_tree:append(
                Tree,
                <<<<"'''\n"/utf8, (erlang:element(3, Tok))/binary>>/binary,
                    "'''"/utf8>>
            );

        _ ->
            gleam@string_tree:append(Tree, erlang:element(3, Tok))
    end.

-file("src/molt/internal/emitter.gleam", 316).
?DOC(false).
-spec emit_token_v1_1(
    gleam@string_tree:string_tree(),
    greenwood:token(molt@types:toml_kind())
) -> gleam@string_tree:string_tree().
emit_token_v1_1(Tree, Tok) ->
    case erlang:element(2, Tok) of
        basic_string ->
            gleam@string_tree:append(
                Tree,
                <<<<"\""/utf8, (erlang:element(3, Tok))/binary>>/binary,
                    "\""/utf8>>
            );

        multiline_basic_string ->
            gleam@string_tree:append(
                Tree,
                <<<<"\"\"\""/utf8, (erlang:element(3, Tok))/binary>>/binary,
                    "\"\"\""/utf8>>
            );

        multiline_basic_string_nl ->
            gleam@string_tree:append(
                Tree,
                <<<<"\"\"\"\n"/utf8, (erlang:element(3, Tok))/binary>>/binary,
                    "\"\"\""/utf8>>
            );

        _ ->
            emit_token_common(Tree, Tok)
    end.

-file("src/molt/internal/emitter.gleam", 114).
?DOC(false).
-spec resolve_newline_token(greenwood:token(molt@types:toml_kind()), binary()) -> greenwood:token(molt@types:toml_kind()).
resolve_newline_token(Tok, Nl) ->
    case {erlang:element(2, Tok), erlang:element(3, Tok)} of
        {newline, <<""/utf8>>} ->
            {token, erlang:element(2, Tok), Nl};

        {_, _} ->
            Tok
    end.

-file("src/molt/internal/emitter.gleam", 95).
?DOC(false).
-spec resolve_newlines(greenwood:node_(molt@types:toml_kind()), binary()) -> greenwood:node_(molt@types:toml_kind()).
resolve_newlines(Node, Nl) ->
    Children = gleam@list:map(erlang:element(3, Node), fun(El) -> case El of
                {token_element, Tok} ->
                    {token_element, resolve_newline_token(Tok, Nl)};

                {node_element, N} ->
                    {node_element, resolve_newlines(N, Nl)}
            end end),
    Trivia = case erlang:element(4, Node) of
        bare ->
            bare;

        {trivia, Leading, Trailing} ->
            {trivia,
                gleam@list:map(
                    Leading,
                    fun(_capture) -> resolve_newline_token(_capture, Nl) end
                ),
                gleam@list:map(
                    Trailing,
                    fun(_capture@1) -> resolve_newline_token(_capture@1, Nl) end
                )}
    end,
    {node, erlang:element(2, Node), Children, Trivia}.

-file("src/molt/internal/emitter.gleam", 141).
?DOC(false).
-spec trailing_newline_run(list(greenwood:token(molt@types:toml_kind()))) -> integer().
trailing_newline_run(Rev) ->
    case Rev of
        [{token, newline, _} | Rest] ->
            1 + trailing_newline_run(Rest);

        [{token, whitespace, _} | Rest@1] ->
            trailing_newline_run(Rest@1);

        _ ->
            0
    end.

-file("src/molt/internal/emitter.gleam", 137).
?DOC(false).
-spec head_separated(list(greenwood:token(molt@types:toml_kind()))) -> boolean().
head_separated(Leading) ->
    trailing_newline_run(lists:reverse(Leading)) >= 2.

-file("src/molt/internal/emitter.gleam", 125).
?DOC(false).
-spec has_statement_child(list(greenwood:element(molt@types:toml_kind()))) -> boolean().
has_statement_child(Children) ->
    gleam@list:any(Children, fun(El) -> case El of
                {node_element, N} ->
                    erlang:element(2, N) /= post_script;

                {token_element, _} ->
                    false
            end end).

-file("src/molt/internal/emitter.gleam", 121).
?DOC(false).
-spec leading_has_comment(list(greenwood:token(molt@types:toml_kind()))) -> boolean().
leading_has_comment(Tokens) ->
    gleam@list:any(Tokens, fun(T) -> erlang:element(2, T) =:= comment end).

-file("src/molt/internal/emitter.gleam", 66).
?DOC(false).
-spec ensure_head_separation(greenwood:node_(molt@types:toml_kind())) -> greenwood:node_(molt@types:toml_kind()).
ensure_head_separation(Node) ->
    case erlang:element(4, Node) of
        {trivia, Leading, Trailing} ->
            case (leading_has_comment(Leading) andalso has_statement_child(
                erlang:element(3, Node)
            ))
            andalso not head_separated(Leading) of
                true ->
                    {node,
                        erlang:element(2, Node),
                        erlang:element(3, Node),
                        {trivia,
                            lists:append(
                                Leading,
                                [{token, newline, <<""/utf8>>}]
                            ),
                            Trailing}};

                false ->
                    Node
            end;

        bare ->
            Node
    end.

-file("src/molt/internal/emitter.gleam", 160).
?DOC(false).
-spec emit_v1_1(greenwood:node_(molt@types:toml_kind())) -> binary().
emit_v1_1(Node) ->
    Nl = molt@internal@cst@elements:document_newline(Node),
    Node@1 = begin
        _pipe = Node,
        _pipe@1 = ensure_head_separation(_pipe),
        _pipe@2 = resolve_newlines(_pipe@1, Nl),
        molt@internal@cst@elements:inline_trailing_trivia(_pipe@2)
    end,
    Visitor = begin
        _pipe@3 = greenwood:visitor(),
        _pipe@4 = greenwood:on_trivia(
            _pipe@3,
            fun(Tree, Tok) -> {continue, emit_token_v1_1(Tree, Tok)} end
        ),
        greenwood:on_token(
            _pipe@4,
            fun(Tree@1, Tok@1) -> {continue, emit_token_v1_1(Tree@1, Tok@1)} end
        )
    end,
    _pipe@5 = greenwood:traverse(Node@1, gleam@string_tree:new(), Visitor),
    unicode:characters_to_binary(_pipe@5).

-file("src/molt/internal/emitter.gleam", 420).
?DOC(false).
-spec is_newline_token(greenwood:token(molt@types:toml_kind())) -> boolean().
is_newline_token(Tok) ->
    erlang:element(2, Tok) =:= newline.

-file("src/molt/internal/emitter.gleam", 411).
?DOC(false).
-spec trivia_has_newline(greenwood:trivia(molt@types:toml_kind())) -> boolean().
trivia_has_newline(Trivia) ->
    case Trivia of
        bare ->
            false;

        {trivia, Leading, Trailing} ->
            gleam@list:any(Leading, fun is_newline_token/1) orelse gleam@list:any(
                Trailing,
                fun is_newline_token/1
            )
    end.

-file("src/molt/internal/emitter.gleam", 396).
?DOC(false).
-spec has_structural_newline(list(greenwood:element(molt@types:toml_kind()))) -> boolean().
has_structural_newline(Elements) ->
    gleam@list:any(Elements, fun(El) -> case El of
                {token_element, {token, newline, _}} ->
                    true;

                {token_element, _} ->
                    false;

                {node_element, N} ->
                    case erlang:element(2, N) of
                        array ->
                            trivia_has_newline(erlang:element(4, N));

                        inline_table ->
                            trivia_has_newline(erlang:element(4, N));

                        _ ->
                            trivia_has_newline(erlang:element(4, N)) orelse has_structural_newline(
                                erlang:element(3, N)
                            )
                    end
            end end).

-file("src/molt/internal/emitter.gleam", 392).
?DOC(false).
-spec is_multiline_inline_table(greenwood:node_(molt@types:toml_kind())) -> boolean().
is_multiline_inline_table(Node) ->
    has_structural_newline(erlang:element(3, Node)).

-file("src/molt/internal/emitter.gleam", 377).
?DOC(false).
-spec pad_local_time(binary()) -> binary().
pad_local_time(Text) ->
    gleam@bool:guard(
        string:length(Text) =:= 5,
        <<Text/binary, ":00"/utf8>>,
        fun() -> Text end
    ).

-file("src/molt/internal/emitter.gleam", 359).
?DOC(false).
-spec do_rewrite_v1_0_escapes(list(binary()), gleam@string_tree:string_tree()) -> gleam@string_tree:string_tree().
do_rewrite_v1_0_escapes(Chars, Tree) ->
    case Chars of
        [] ->
            Tree;

        [<<"\\"/utf8>>, <<"e"/utf8>> | Rest] ->
            do_rewrite_v1_0_escapes(
                Rest,
                gleam@string_tree:append(Tree, <<"\\u001B"/utf8>>)
            );

        [<<"\\"/utf8>>, <<"x"/utf8>>, H1, H2 | Rest@1] ->
            do_rewrite_v1_0_escapes(
                Rest@1,
                gleam@string_tree:append(
                    Tree,
                    <<<<"\\u00"/utf8, H1/binary>>/binary, H2/binary>>
                )
            );

        [Ch | Rest@2] ->
            do_rewrite_v1_0_escapes(Rest@2, gleam@string_tree:append(Tree, Ch))
    end.

-file("src/molt/internal/emitter.gleam", 355).
?DOC(false).
-spec rewrite_v1_0_escapes(binary()) -> gleam@string_tree:string_tree().
rewrite_v1_0_escapes(Text) ->
    do_rewrite_v1_0_escapes(
        gleam@string:to_graphemes(Text),
        gleam@string_tree:new()
    ).

-file("src/molt/internal/emitter.gleam", 296).
?DOC(false).
-spec emit_token_text_v1_0(
    gleam@string_tree:string_tree(),
    greenwood:token(molt@types:toml_kind())
) -> gleam@string_tree:string_tree().
emit_token_text_v1_0(Tree, Tok) ->
    case erlang:element(2, Tok) of
        basic_string ->
            Text = <<<<"\""/utf8, (erlang:element(3, Tok))/binary>>/binary,
                "\""/utf8>>,
            gleam_stdlib:iodata_append(Tree, rewrite_v1_0_escapes(Text));

        multiline_basic_string ->
            Text@1 = <<<<"\"\"\""/utf8, (erlang:element(3, Tok))/binary>>/binary,
                "\"\"\""/utf8>>,
            gleam_stdlib:iodata_append(Tree, rewrite_v1_0_escapes(Text@1));

        multiline_basic_string_nl ->
            Text@2 = <<<<"\"\"\"\n"/utf8, (erlang:element(3, Tok))/binary>>/binary,
                "\"\"\""/utf8>>,
            gleam_stdlib:iodata_append(Tree, rewrite_v1_0_escapes(Text@2));

        local_time ->
            gleam@string_tree:append(
                Tree,
                pad_local_time(erlang:element(3, Tok))
            );

        _ ->
            emit_token_common(Tree, Tok)
    end.

-file("src/molt/internal/emitter.gleam", 281).
?DOC(false).
-spec flush_pending(emit_state()) -> emit_state().
flush_pending(State) ->
    case {erlang:element(6, State), erlang:element(5, State)} of
        {true, _} ->
            Tree = gleam@string_tree:append(
                erlang:element(2, State),
                <<" "/utf8>>
            ),
            {emit_state,
                Tree,
                erlang:element(3, State),
                erlang:element(4, State),
                erlang:element(5, State),
                false};

        {_, true} ->
            Tree@1 = gleam@string_tree:append(
                erlang:element(2, State),
                <<", "/utf8>>
            ),
            {emit_state,
                Tree@1,
                erlang:element(3, State),
                erlang:element(4, State),
                false,
                erlang:element(6, State)};

        {_, _} ->
            State
    end.

-file("src/molt/internal/emitter.gleam", 237).
?DOC(false).
-spec emit_v1_0_token(emit_state(), greenwood:token(molt@types:toml_kind())) -> emit_state().
emit_v1_0_token(State, Tok) ->
    case {erlang:element(3, State) > 0, erlang:element(2, Tok)} of
        {true, newline} ->
            State;

        {true, comment} ->
            State;

        {true, whitespace} ->
            State;

        {true, comma} ->
            {emit_state,
                erlang:element(2, State),
                erlang:element(3, State),
                erlang:element(4, State),
                true,
                erlang:element(6, State)};

        {true, right_brace} ->
            Tree = case erlang:element(6, State) of
                true ->
                    gleam@string_tree:append(
                        erlang:element(2, State),
                        <<"}"/utf8>>
                    );

                false ->
                    gleam@string_tree:append(
                        erlang:element(2, State),
                        <<" }"/utf8>>
                    )
            end,
            {emit_state,
                Tree,
                erlang:element(3, State),
                erlang:element(4, State),
                false,
                false};

        {true, left_brace} ->
            State@1 = flush_pending(State),
            Tree@1 = gleam@string_tree:append(
                erlang:element(2, State@1),
                <<"{"/utf8>>
            ),
            {emit_state,
                Tree@1,
                erlang:element(3, State@1),
                erlang:element(4, State@1),
                erlang:element(5, State@1),
                true};

        {true, equals} ->
            Tree@2 = gleam@string_tree:append(
                erlang:element(2, State),
                <<" = "/utf8>>
            ),
            {emit_state,
                Tree@2,
                erlang:element(3, State),
                erlang:element(4, State),
                erlang:element(5, State),
                erlang:element(6, State)};

        {true, _} ->
            State@2 = flush_pending(State),
            Tree@3 = emit_token_text_v1_0(erlang:element(2, State@2), Tok),
            {emit_state,
                Tree@3,
                erlang:element(3, State@2),
                erlang:element(4, State@2),
                erlang:element(5, State@2),
                erlang:element(6, State@2)};

        {false, _} ->
            Tree@4 = emit_token_text_v1_0(erlang:element(2, State), Tok),
            {emit_state,
                Tree@4,
                erlang:element(3, State),
                erlang:element(4, State),
                erlang:element(5, State),
                erlang:element(6, State)}
    end.

-file("src/molt/internal/emitter.gleam", 190).
?DOC(false).
-spec emit_v1_0(greenwood:node_(molt@types:toml_kind())) -> binary().
emit_v1_0(Node) ->
    Nl = molt@internal@cst@elements:document_newline(Node),
    Node@1 = begin
        _pipe = Node,
        _pipe@1 = ensure_head_separation(_pipe),
        _pipe@2 = resolve_newlines(_pipe@1, Nl),
        molt@internal@cst@elements:inline_trailing_trivia(_pipe@2)
    end,
    Visitor = begin
        _pipe@3 = greenwood:visitor(),
        _pipe@4 = greenwood:on_trivia(
            _pipe@3,
            fun(State, Tok) -> {continue, emit_v1_0_token(State, Tok)} end
        ),
        _pipe@5 = greenwood:on_token(
            _pipe@4,
            fun(State@1, Tok@1) ->
                {continue, emit_v1_0_token(State@1, Tok@1)}
            end
        ),
        _pipe@6 = greenwood:on_enter_node(
            _pipe@5,
            fun(State@2, Node@2) ->
                State@3 = {emit_state,
                    erlang:element(2, State@2),
                    erlang:element(3, State@2),
                    erlang:element(4, State@2) + 1,
                    erlang:element(5, State@2),
                    erlang:element(6, State@2)},
                case (erlang:element(2, Node@2) =:= inline_table) andalso is_multiline_inline_table(
                    Node@2
                ) of
                    true ->
                        {continue,
                            {emit_state,
                                erlang:element(2, State@3),
                                erlang:element(3, State@3) + 1,
                                erlang:element(4, State@3),
                                erlang:element(5, State@3),
                                erlang:element(6, State@3)}};

                    false ->
                        {continue, State@3}
                end
            end
        ),
        greenwood:on_exit_node(
            _pipe@6,
            fun(State@4, Node@3) ->
                State@5 = {emit_state,
                    erlang:element(2, State@4),
                    erlang:element(3, State@4),
                    erlang:element(4, State@4) - 1,
                    erlang:element(5, State@4),
                    erlang:element(6, State@4)},
                case (erlang:element(2, Node@3) =:= inline_table) andalso is_multiline_inline_table(
                    Node@3
                ) of
                    true ->
                        {continue,
                            {emit_state,
                                erlang:element(2, State@5),
                                erlang:element(3, State@5) - 1,
                                erlang:element(4, State@5),
                                erlang:element(5, State@5),
                                erlang:element(6, State@5)}};

                    false ->
                        {continue, State@5}
                end
            end
        )
    end,
    State@6 = greenwood:traverse(
        Node@1,
        {emit_state, gleam@string_tree:new(), 0, 0, false, false},
        Visitor
    ),
    unicode:characters_to_binary(erlang:element(2, State@6)).

-file("src/molt/internal/emitter.gleam", 150).
?DOC(false).
-spec emit_versioned(
    greenwood:node_(molt@types:toml_kind()),
    molt@types:toml_version()
) -> binary().
emit_versioned(Node, Version) ->
    case Version =:= {toml_version, <<"1.0"/utf8>>} of
        true ->
            emit_v1_0(Node);

        false ->
            emit_v1_1(Node)
    end.

-file("src/molt/internal/emitter.gleam", 54).
?DOC(false).
-spec emit(greenwood:node_(molt@types:toml_kind())) -> binary().
emit(Node) ->
    emit_versioned(Node, {toml_version, <<"1.1"/utf8>>}).