-module(simplejson@internal@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/simplejson/internal/parser.gleam").
-export([list_to_indexed_dict/1, parse/1]).

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

?MODULEDOC(false).

-file("src/simplejson/internal/parser.gleam", 48).
?DOC(false).
-spec create_error(
    fun((binary(), binary(), integer()) -> simplejson@jsonvalue:parse_error()),
    binary(),
    binary(),
    binary()
) -> simplejson@jsonvalue:parse_error().
create_error(Constructor, Json, Rest, Char) ->
    First_char@1 = case case Char of
        <<""/utf8>> ->
            gleam@string:first(Rest);

        _ ->
            {ok, Char}
    end of
        {ok, First_char} -> First_char;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"simplejson/internal/parser"/utf8>>,
                        function => <<"create_error"/utf8>>,
                        line => 54,
                        value => _assert_fail,
                        start => 1630,
                        'end' => 1720,
                        pattern_start => 1641,
                        pattern_end => 1655})
    end,
    Initial_str@1 = case gleam@string:split_once(
        <<Json/binary, "\x{00}"/utf8>>,
        <<Rest/binary, "\x{00}"/utf8>>
    ) of
        {ok, {Initial_str, _}} -> Initial_str;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"simplejson/internal/parser"/utf8>>,
                        function => <<"create_error"/utf8>>,
                        line => 58,
                        value => _assert_fail@1,
                        start => 1723,
                        'end' => 1815,
                        pattern_start => 1734,
                        pattern_end => 1755})
    end,
    Start_pos = string:length(Initial_str@1),
    Constructor(
        First_char@1,
        gleam@string:slice(
            Json,
            gleam@int:max(0, Start_pos - 5),
            gleam@int:min(string:length(Json), Start_pos + 5)
        ),
        Start_pos
    ).

-file("src/simplejson/internal/parser.gleam", 114).
?DOC(false).
-spec do_trim_whitespace(binary()) -> binary().
do_trim_whitespace(Json) ->
    case Json of
        <<" "/utf8, Rest/binary>> ->
            do_trim_whitespace(Rest);

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

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

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

        _ ->
            Json
    end.

-file("src/simplejson/internal/parser.gleam", 261).
?DOC(false).
-spec parse_hex(binary()) -> {ok, {binary(), binary()}} |
    {error, simplejson@jsonvalue:parse_error()}.
parse_hex(Json) ->
    Hex = gleam@string:slice(Json, 0, 4),
    gleam@bool:guard(
        string:length(Hex) < 4,
        {error, unexpected_end},
        fun() ->
            Rest = gleam@string:drop_start(Json, 4),
            gleam@result:'try'(
                begin
                    _pipe = gleam@int:base_parse(Hex, 16),
                    gleam@result:map_error(
                        _pipe,
                        fun(_) -> {invalid_hex, Hex, Json, -1} end
                    )
                end,
                fun(Parsed) -> case Parsed of
                        65534 ->
                            {ok, {Rest, <<""/utf8>>}};

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

                        _ ->
                            gleam@result:'try'(
                                begin
                                    _pipe@1 = gleam@string:utf_codepoint(Parsed),
                                    gleam@result:map_error(
                                        _pipe@1,
                                        fun(_) ->
                                            {invalid_hex, Hex, Json, -1}
                                        end
                                    )
                                end,
                                fun(Utf8) ->
                                    {ok,
                                        {Rest,
                                            gleam_stdlib:utf_codepoint_list_to_string(
                                                [Utf8]
                                            )}}
                                end
                            )
                    end end
            )
        end
    ).

-file("src/simplejson/internal/parser.gleam", 190).
?DOC(false).
-spec do_parse_string(binary(), binary()) -> {ok,
        {binary(), simplejson@jsonvalue:json_value()}} |
    {error, simplejson@jsonvalue:parse_error()}.
do_parse_string(Json, Str) ->
    case Json of
        <<"\""/utf8, Rest/binary>> ->
            {ok, {Rest, {json_string, Str}}};

        <<"\\"/utf8, Rest@1/binary>> ->
            case Rest@1 of
                <<"\""/utf8, Rest@2/binary>> ->
                    do_parse_string(Rest@2, <<Str/binary, "\""/utf8>>);

                <<"\\"/utf8, Rest@3/binary>> ->
                    do_parse_string(Rest@3, <<Str/binary, "\\"/utf8>>);

                <<"/"/utf8, Rest@4/binary>> ->
                    do_parse_string(Rest@4, <<Str/binary, "/"/utf8>>);

                <<"b"/utf8, Rest@5/binary>> ->
                    do_parse_string(Rest@5, <<Str/binary, "\x{08}"/utf8>>);

                <<"f"/utf8, Rest@6/binary>> ->
                    do_parse_string(Rest@6, <<Str/binary, "\f"/utf8>>);

                <<"n"/utf8, Rest@7/binary>> ->
                    do_parse_string(Rest@7, <<Str/binary, "\n"/utf8>>);

                <<"r"/utf8, Rest@8/binary>> ->
                    do_parse_string(Rest@8, <<Str/binary, "\r"/utf8>>);

                <<"t"/utf8, Rest@9/binary>> ->
                    do_parse_string(Rest@9, <<Str/binary, "\t"/utf8>>);

                <<"u"/utf8, Rest@10/binary>> ->
                    gleam@result:'try'(
                        parse_hex(Rest@10),
                        fun(_use0) ->
                            {Rest@11, Char} = _use0,
                            do_parse_string(
                                Rest@11,
                                <<Str/binary, Char/binary>>
                            )
                        end
                    );

                <<""/utf8>> ->
                    {error, unexpected_end};

                _ ->
                    First_char@1 = case gleam@string:first(Rest@1) of
                        {ok, First_char} -> First_char;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"simplejson/internal/parser"/utf8>>,
                                        function => <<"do_parse_string"/utf8>>,
                                        line => 212,
                                        value => _assert_fail,
                                        start => 5933,
                                        'end' => 5979,
                                        pattern_start => 5944,
                                        pattern_end => 5958})
                    end,
                    {error, {invalid_escape_character, First_char@1, Json, -1}}
            end;

        <<"\x{00}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{01}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{02}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{03}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{04}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{05}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{06}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{07}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{08}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{09}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{0A}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{0B}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{0C}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{0D}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{0E}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{0F}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{10}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{11}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{12}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{13}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{14}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{15}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{16}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{17}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{18}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{19}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{1A}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{1B}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{1C}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{1D}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{1E}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        <<"\x{1F}"/utf8, _/binary>> ->
            First_char@3 = case gleam@string:first(Json) of
                {ok, First_char@2} -> First_char@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"do_parse_string"/utf8>>,
                                line => 249,
                                value => _assert_fail@1,
                                start => 6715,
                                'end' => 6761,
                                pattern_start => 6726,
                                pattern_end => 6740})
            end,
            {error, {invalid_character, First_char@3, Json, -1}};

        _ ->
            gleam@result:'try'(
                begin
                    _pipe = gleam_stdlib:string_pop_grapheme(Json),
                    gleam@result:map_error(_pipe, fun(_) -> unexpected_end end)
                end,
                fun(_use0@1) ->
                    {Char@1, Rest@12} = _use0@1,
                    do_parse_string(Rest@12, <<Str/binary, Char@1/binary>>)
                end
            )
    end.

-file("src/simplejson/internal/parser.gleam", 490).
?DOC(false).
-spec exp2(integer(), integer(), integer()) -> integer().
exp2(Y, X, N) ->
    case gleam@int:compare(N, 0) of
        eq ->
            Y;

        lt ->
            -999;

        gt ->
            case gleam@int:is_even(N) of
                true ->
                    exp2(Y, X * X, N div 2);

                false ->
                    exp2(X * Y, X * X, (N - 1) div 2)
            end
    end.

-file("src/simplejson/internal/parser.gleam", 486).
?DOC(false).
-spec fast_exp(integer()) -> integer().
fast_exp(N) ->
    exp2(1, 10, N).

-file("src/simplejson/internal/parser.gleam", 465).
?DOC(false).
-spec decode_int(binary(), binary(), integer()) -> integer().
decode_int(Int_val, Fraction, Exp) ->
    Int_val@2 = case gleam_stdlib:parse_int(Int_val) of
        {ok, Int_val@1} -> Int_val@1;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"simplejson/internal/parser"/utf8>>,
                        function => <<"decode_int"/utf8>>,
                        line => 466,
                        value => _assert_fail,
                        start => 12511,
                        'end' => 12554,
                        pattern_start => 12522,
                        pattern_end => 12533})
    end,
    {Int_val@3, Exp@1} = case Fraction of
        <<""/utf8>> ->
            {Int_val@2, Exp};

        Fraction@1 ->
            Fraction_length = string:length(Fraction@1),
            Fraction@3 = case gleam_stdlib:parse_int(Fraction@1) of
                {ok, Fraction@2} -> Fraction@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"decode_int"/utf8>>,
                                line => 471,
                                value => _assert_fail@1,
                                start => 12697,
                                'end' => 12742,
                                pattern_start => 12708,
                                pattern_end => 12720})
            end,
            {(Int_val@2 * fast_exp(Fraction_length)) + Fraction@3,
                Exp - Fraction_length}
    end,
    case Exp@1 < 0 of
        true ->
            case fast_exp(- Exp@1) of
                0 -> 0;
                Gleam@denominator -> Int_val@3 div Gleam@denominator
            end;

        false ->
            Int_val@3 * fast_exp(Exp@1)
    end.

-file("src/simplejson/internal/parser.gleam", 503).
?DOC(false).
-spec decode_float(binary(), binary(), integer()) -> float().
decode_float(Int_val, Fraction, Exp) ->
    Float_val = case Fraction of
        <<""/utf8>> ->
            <<Int_val/binary, ".0"/utf8>>;

        _ ->
            <<<<Int_val/binary, "."/utf8>>/binary, Fraction/binary>>
    end,
    Float_val@2 = case gleam_stdlib:parse_float(Float_val) of
        {ok, Float_val@1} -> Float_val@1;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"simplejson/internal/parser"/utf8>>,
                        function => <<"decode_float"/utf8>>,
                        line => 508,
                        value => _assert_fail,
                        start => 13427,
                        'end' => 13476,
                        pattern_start => 13438,
                        pattern_end => 13451})
    end,
    case gleam@int:compare(Exp, 0) of
        eq ->
            Float_val@2;

        gt ->
            Float_val@2 * erlang:float(fast_exp(Exp));

        lt ->
            Mult@1 = case gleam@int:power(10, erlang:float(Exp)) of
                {ok, Mult} -> Mult;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/parser"/utf8>>,
                                function => <<"decode_float"/utf8>>,
                                line => 515,
                                value => _assert_fail@1,
                                start => 13609,
                                'end' => 13663,
                                pattern_start => 13620,
                                pattern_end => 13628})
            end,
            Float_val@2 * Mult@1
    end.

-file("src/simplejson/internal/parser.gleam", 532).
?DOC(false).
-spec do_parse_int(binary(), boolean(), binary()) -> {ok, {binary(), binary()}} |
    {error, simplejson@jsonvalue:parse_error()}.
do_parse_int(Json, Allow_leading_zeroes, Num) ->
    case Json of
        <<N:1/binary, Rest/binary>> when N =:= <<"0"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        <<N:1/binary, Rest/binary>> when N =:= <<"1"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        <<N:1/binary, Rest/binary>> when N =:= <<"2"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        <<N:1/binary, Rest/binary>> when N =:= <<"3"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        <<N:1/binary, Rest/binary>> when N =:= <<"4"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        <<N:1/binary, Rest/binary>> when N =:= <<"5"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        <<N:1/binary, Rest/binary>> when N =:= <<"6"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        <<N:1/binary, Rest/binary>> when N =:= <<"7"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        <<N:1/binary, Rest/binary>> when N =:= <<"8"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        <<N:1/binary, Rest/binary>> when N =:= <<"9"/utf8>> ->
            do_parse_int(Rest, Allow_leading_zeroes, <<Num/binary, N/binary>>);

        _ ->
            case Num of
                <<""/utf8>> ->
                    {error,
                        {invalid_number,
                            <<Num/binary, ((case gleam@string:first(Json) of
                                    {ok, Char} ->
                                        Char;

                                    _ ->
                                        <<""/utf8>>
                                end))/binary>>,
                            <<Num/binary, Json/binary>>,
                            -1}};

                <<"-"/utf8>> ->
                    {error,
                        {invalid_number,
                            <<Num/binary, ((case gleam@string:first(Json) of
                                    {ok, Char} ->
                                        Char;

                                    _ ->
                                        <<""/utf8>>
                                end))/binary>>,
                            <<Num/binary, Json/binary>>,
                            -1}};

                _ ->
                    case (Allow_leading_zeroes orelse (Num =:= <<"0"/utf8>>))
                    orelse (Num =:= <<"-0"/utf8>>) of
                        true ->
                            {ok, {Json, Num}};

                        false ->
                            case gleam_stdlib:string_starts_with(
                                Num,
                                <<"0"/utf8>>
                            )
                            orelse gleam_stdlib:string_starts_with(
                                Num,
                                <<"-0"/utf8>>
                            ) of
                                true ->
                                    {error,
                                        {invalid_number,
                                            Num,
                                            <<Num/binary, Json/binary>>,
                                            -1}};

                                false ->
                                    {ok, {Json, Num}}
                            end
                    end
            end
    end.

-file("src/simplejson/internal/parser.gleam", 522).
?DOC(false).
-spec do_parse_exponent(binary()) -> {ok, {binary(), binary()}} |
    {error, simplejson@jsonvalue:parse_error()}.
do_parse_exponent(Json) ->
    gleam@result:'try'(case Json of
            <<"+"/utf8, Rest/binary>> ->
                do_parse_int(Rest, true, <<""/utf8>>);

            <<"-"/utf8, Rest@1/binary>> ->
                do_parse_int(Rest@1, true, <<"-"/utf8>>);

            _ ->
                do_parse_int(Json, true, <<""/utf8>>)
        end, fun(_use0) ->
            {Json@1, Exp} = _use0,
            {ok, {Json@1, Exp}}
        end).

-file("src/simplejson/internal/parser.gleam", 327).
?DOC(false).
-spec do_parse_number(binary()) -> {ok,
        {binary(), simplejson@jsonvalue:json_value()}} |
    {error, simplejson@jsonvalue:parse_error()}.
do_parse_number(Original_json) ->
    gleam@result:'try'(case Original_json of
            <<"-"/utf8, Rest/binary>> ->
                do_parse_int(Rest, false, <<"-"/utf8>>);

            Json ->
                do_parse_int(Json, false, <<""/utf8>>)
        end, fun(_use0) ->
            {Json@1, Num} = _use0,
            gleam@result:'try'(
                begin
                    _pipe = case Json@1 of
                        <<"."/utf8, Rest@1/binary>> ->
                            do_parse_int(Rest@1, true, <<""/utf8>>);

                        _ ->
                            {ok, {Json@1, <<""/utf8>>}}
                    end,
                    gleam@result:map_error(_pipe, fun(Err) -> case Err of
                                {invalid_number, Fraction, _, _} ->
                                    {invalid_number,
                                        <<<<Num/binary, "."/utf8>>/binary,
                                            Fraction/binary>>,
                                        Original_json,
                                        -1};

                                _ ->
                                    Err
                            end end)
                end,
                fun(_use0@1) ->
                    {Json@2, Fraction@1} = _use0@1,
                    gleam@result:'try'(
                        begin
                            _pipe@1 = case Json@2 of
                                <<"e"/utf8, Rest@2/binary>> ->
                                    do_parse_exponent(Rest@2);

                                <<"E"/utf8, Rest@2/binary>> ->
                                    do_parse_exponent(Rest@2);

                                _ ->
                                    {ok, {Json@2, <<""/utf8>>}}
                            end,
                            gleam@result:map_error(
                                _pipe@1,
                                fun(Err@1) -> case Err@1 of
                                        {invalid_number, Exp, _, _} ->
                                            Invalid_num = <<Num/binary,
                                                ((case Fraction@1 of
                                                    <<""/utf8>> ->
                                                        <<""/utf8>>;

                                                    _ ->
                                                        <<"."/utf8,
                                                            Fraction@1/binary>>
                                                end))/binary>>,
                                            {invalid_number,
                                                <<<<Invalid_num/binary,
                                                        "e"/utf8>>/binary,
                                                    Exp/binary>>,
                                                Original_json,
                                                -1};

                                        _ ->
                                            Err@1
                                    end end
                            )
                        end,
                        fun(_use0@2) ->
                            {Json@3, Exp@1} = _use0@2,
                            Original = <<<<Num/binary, ((case Fraction@1 of
                                        <<""/utf8>> ->
                                            <<""/utf8>>;

                                        _ ->
                                            <<"."/utf8, Fraction@1/binary>>
                                    end))/binary>>/binary, ((case Exp@1 of
                                    <<""/utf8>> ->
                                        <<""/utf8>>;

                                    _ ->
                                        <<"e"/utf8, Exp@1/binary>>
                                end))/binary>>,
                            gleam@result:'try'(case {Fraction@1, Exp@1} of
                                    {<<""/utf8>>, <<""/utf8>>} ->
                                        {ok,
                                            {json_number,
                                                {some,
                                                    decode_int(
                                                        Num,
                                                        <<""/utf8>>,
                                                        0
                                                    )},
                                                none,
                                                {some, Original}}};

                                    {<<""/utf8>>, <<"-"/utf8, Exp@2/binary>>} ->
                                        gleam@result:'try'(
                                            begin
                                                _pipe@2 = gleam_stdlib:parse_int(
                                                    Exp@2
                                                ),
                                                gleam@result:map_error(
                                                    _pipe@2,
                                                    fun(_) ->
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}
                                                    end
                                                )
                                            end,
                                            fun(Exp@3) ->
                                                case gleam_stdlib:string_ends_with(
                                                    Num,
                                                    gleam@string:repeat(
                                                        <<"0"/utf8>>,
                                                        Exp@3
                                                    )
                                                ) of
                                                    true ->
                                                        {ok,
                                                            {json_number,
                                                                {some,
                                                                    decode_int(
                                                                        Num,
                                                                        <<""/utf8>>,
                                                                        - Exp@3
                                                                    )},
                                                                none,
                                                                {some, Original}}};

                                                    false ->
                                                        {ok,
                                                            {json_number,
                                                                none,
                                                                {some,
                                                                    decode_float(
                                                                        Num,
                                                                        Fraction@1,
                                                                        - Exp@3
                                                                    )},
                                                                {some, Original}}}
                                                end
                                            end
                                        );

                                    {<<""/utf8>>, <<"+"/utf8, Exp@4/binary>>} ->
                                        gleam@result:'try'(
                                            begin
                                                _pipe@3 = gleam_stdlib:parse_int(
                                                    Exp@4
                                                ),
                                                gleam@result:map_error(
                                                    _pipe@3,
                                                    fun(_) ->
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}
                                                    end
                                                )
                                            end,
                                            fun(Exp@5) ->
                                                gleam@bool:guard(
                                                    Exp@5 > 1000000,
                                                    {error,
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}},
                                                    fun() ->
                                                        {ok,
                                                            {json_number,
                                                                {some,
                                                                    decode_int(
                                                                        Num,
                                                                        <<""/utf8>>,
                                                                        Exp@5
                                                                    )},
                                                                none,
                                                                {some, Original}}}
                                                    end
                                                )
                                            end
                                        );

                                    {<<""/utf8>>, Exp@4} ->
                                        gleam@result:'try'(
                                            begin
                                                _pipe@3 = gleam_stdlib:parse_int(
                                                    Exp@4
                                                ),
                                                gleam@result:map_error(
                                                    _pipe@3,
                                                    fun(_) ->
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}
                                                    end
                                                )
                                            end,
                                            fun(Exp@5) ->
                                                gleam@bool:guard(
                                                    Exp@5 > 1000000,
                                                    {error,
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}},
                                                    fun() ->
                                                        {ok,
                                                            {json_number,
                                                                {some,
                                                                    decode_int(
                                                                        Num,
                                                                        <<""/utf8>>,
                                                                        Exp@5
                                                                    )},
                                                                none,
                                                                {some, Original}}}
                                                    end
                                                )
                                            end
                                        );

                                    {_, <<""/utf8>>} ->
                                        {ok,
                                            {json_number,
                                                none,
                                                {some,
                                                    decode_float(
                                                        Num,
                                                        Fraction@1,
                                                        0
                                                    )},
                                                {some, Original}}};

                                    {_, <<"-"/utf8, Exp@6/binary>>} ->
                                        gleam@result:'try'(
                                            begin
                                                _pipe@4 = gleam_stdlib:parse_int(
                                                    Exp@6
                                                ),
                                                gleam@result:map_error(
                                                    _pipe@4,
                                                    fun(_) ->
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}
                                                    end
                                                )
                                            end,
                                            fun(Exp@7) ->
                                                {ok,
                                                    {json_number,
                                                        none,
                                                        {some,
                                                            decode_float(
                                                                Num,
                                                                Fraction@1,
                                                                - Exp@7
                                                            )},
                                                        {some, Original}}}
                                            end
                                        );

                                    {_, <<"+"/utf8, Exp@8/binary>>} ->
                                        gleam@result:'try'(
                                            begin
                                                _pipe@5 = gleam_stdlib:parse_int(
                                                    Exp@8
                                                ),
                                                gleam@result:map_error(
                                                    _pipe@5,
                                                    fun(_) ->
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}
                                                    end
                                                )
                                            end,
                                            fun(Exp@9) ->
                                                gleam@bool:guard(
                                                    Exp@9 > 1000000,
                                                    {error,
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}},
                                                    fun() ->
                                                        Fraction_length = string:length(
                                                            Fraction@1
                                                        ),
                                                        case Exp@9 >= Fraction_length of
                                                            true ->
                                                                {ok,
                                                                    {json_number,
                                                                        {some,
                                                                            decode_int(
                                                                                Num,
                                                                                Fraction@1,
                                                                                Exp@9
                                                                            )},
                                                                        none,
                                                                        {some,
                                                                            Original}}};

                                                            false ->
                                                                {ok,
                                                                    {json_number,
                                                                        none,
                                                                        {some,
                                                                            decode_float(
                                                                                Num,
                                                                                Fraction@1,
                                                                                Exp@9
                                                                            )},
                                                                        {some,
                                                                            Original}}}
                                                        end
                                                    end
                                                )
                                            end
                                        );

                                    {_, Exp@8} ->
                                        gleam@result:'try'(
                                            begin
                                                _pipe@5 = gleam_stdlib:parse_int(
                                                    Exp@8
                                                ),
                                                gleam@result:map_error(
                                                    _pipe@5,
                                                    fun(_) ->
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}
                                                    end
                                                )
                                            end,
                                            fun(Exp@9) ->
                                                gleam@bool:guard(
                                                    Exp@9 > 1000000,
                                                    {error,
                                                        {invalid_number,
                                                            Original,
                                                            Original_json,
                                                            -1}},
                                                    fun() ->
                                                        Fraction_length = string:length(
                                                            Fraction@1
                                                        ),
                                                        case Exp@9 >= Fraction_length of
                                                            true ->
                                                                {ok,
                                                                    {json_number,
                                                                        {some,
                                                                            decode_int(
                                                                                Num,
                                                                                Fraction@1,
                                                                                Exp@9
                                                                            )},
                                                                        none,
                                                                        {some,
                                                                            Original}}};

                                                            false ->
                                                                {ok,
                                                                    {json_number,
                                                                        none,
                                                                        {some,
                                                                            decode_float(
                                                                                Num,
                                                                                Fraction@1,
                                                                                Exp@9
                                                                            )},
                                                                        {some,
                                                                            Original}}}
                                                        end
                                                    end
                                                )
                                            end
                                        )
                                end, fun(Ret) -> {ok, {Json@3, Ret}} end)
                        end
                    )
                end
            )
        end).

-file("src/simplejson/internal/parser.gleam", 583).
?DOC(false).
-spec list_to_indexed_dict(list(QOV)) -> gleam@dict:dict(integer(), QOV).
list_to_indexed_dict(Initial_list) ->
    gleam@list:index_fold(
        Initial_list,
        maps:new(),
        fun(Current_dict, Item, Index) ->
            gleam@dict:insert(Current_dict, Index, Item)
        end
    ).

-file("src/simplejson/internal/parser.gleam", 122).
?DOC(false).
-spec do_parse_object(
    binary(),
    gleam@dict:dict(binary(), simplejson@jsonvalue:json_value()),
    gleam@option:option({gleam@option:option(nil),
        gleam@option:option(binary()),
        gleam@option:option(simplejson@jsonvalue:json_value())}),
    integer()
) -> {ok, {binary(), simplejson@jsonvalue:json_value()}} |
    {error, simplejson@jsonvalue:parse_error()}.
do_parse_object(Json, Obj, Last_entry, Current_depth) ->
    gleam@bool:guard(
        Current_depth > 512,
        {error, {nesting_depth, Current_depth}},
        fun() ->
            Trimmed_json = do_trim_whitespace(Json),
            case Trimmed_json of
                <<"}"/utf8, Rest/binary>> ->
                    case Last_entry of
                        none ->
                            {ok, {Rest, {json_object, Obj}}};

                        {some, {none, none, none}} ->
                            {ok, {Rest, {json_object, Obj}}};

                        _ ->
                            {error,
                                {unexpected_character,
                                    <<"}"/utf8>>,
                                    Trimmed_json,
                                    -1}}
                    end;

                <<"\""/utf8, Rest@1/binary>> ->
                    case Last_entry of
                        none ->
                            case do_parse_string(Rest@1, <<""/utf8>>) of
                                {ok, {Rest@2, {json_string, Key}}} ->
                                    do_parse_object(
                                        Rest@2,
                                        Obj,
                                        {some, {{some, nil}, {some, Key}, none}},
                                        Current_depth
                                    );

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

                                {ok, _} ->
                                    {error, unknown}
                            end;

                        {some, {{some, nil}, none, none}} ->
                            case do_parse_string(Rest@1, <<""/utf8>>) of
                                {ok, {Rest@2, {json_string, Key}}} ->
                                    do_parse_object(
                                        Rest@2,
                                        Obj,
                                        {some, {{some, nil}, {some, Key}, none}},
                                        Current_depth
                                    );

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

                                {ok, _} ->
                                    {error, unknown}
                            end;

                        _ ->
                            {error,
                                {unexpected_character,
                                    <<"\""/utf8>>,
                                    Trimmed_json,
                                    -1}}
                    end;

                <<":"/utf8, Rest@3/binary>> ->
                    case Last_entry of
                        {some, {{some, nil}, {some, Key@1}, none}} ->
                            gleam@result:'try'(
                                do_parse(Rest@3, Current_depth),
                                fun(_use0) ->
                                    {Rest@4, Value} = _use0,
                                    do_parse_object(
                                        Rest@4,
                                        gleam@dict:insert(Obj, Key@1, Value),
                                        {some, {none, none, none}},
                                        Current_depth
                                    )
                                end
                            );

                        _ ->
                            {error,
                                {unexpected_character,
                                    <<":"/utf8>>,
                                    Trimmed_json,
                                    -1}}
                    end;

                <<","/utf8, Rest@5/binary>> ->
                    case Last_entry of
                        {some, {none, none, none}} ->
                            do_parse_object(
                                Rest@5,
                                Obj,
                                {some, {{some, nil}, none, none}},
                                Current_depth
                            );

                        _ ->
                            {error,
                                {unexpected_character,
                                    <<","/utf8>>,
                                    Trimmed_json,
                                    -1}}
                    end;

                <<""/utf8>> ->
                    {error, unexpected_end};

                _ ->
                    {error,
                        {unexpected_character, <<""/utf8>>, Trimmed_json, -1}}
            end
        end
    ).

-file("src/simplejson/internal/parser.gleam", 72).
?DOC(false).
-spec do_parse(binary(), integer()) -> {ok,
        {binary(), simplejson@jsonvalue:json_value()}} |
    {error, simplejson@jsonvalue:parse_error()}.
do_parse(Json, Current_depth) ->
    Json@1 = do_trim_whitespace(Json),
    case Json@1 of
        <<"["/utf8, Rest/binary>> ->
            do_parse_list(Rest, [], none, Current_depth + 1);

        <<"{"/utf8, Rest@1/binary>> ->
            do_parse_object(Rest@1, maps:new(), none, Current_depth + 1);

        <<"\""/utf8, Rest@2/binary>> ->
            do_parse_string(Rest@2, <<""/utf8>>);

        <<"true"/utf8, Rest@3/binary>> ->
            {ok, {Rest@3, {json_bool, true}}};

        <<"false"/utf8, Rest@4/binary>> ->
            {ok, {Rest@4, {json_bool, false}}};

        <<"null"/utf8, Rest@5/binary>> ->
            {ok, {Rest@5, json_null}};

        <<"-"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"0"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"1"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"2"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"3"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"4"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"5"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"6"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"7"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"8"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<"9"/utf8, _/binary>> ->
            do_parse_number(Json@1);

        <<""/utf8>> ->
            {error, unexpected_end};

        _ ->
            {error, {unexpected_character, <<""/utf8>>, Json@1, -1}}
    end.

-file("src/simplejson/internal/parser.gleam", 19).
?DOC(false).
-spec parse(binary()) -> {ok, simplejson@jsonvalue:json_value()} |
    {error, simplejson@jsonvalue:parse_error()}.
parse(Json) ->
    Json@1 = do_trim_whitespace(Json),
    case do_parse(Json@1, 0) of
        {ok, {Rest, Json_value}} ->
            Rest@1 = do_trim_whitespace(Rest),
            case Rest@1 of
                <<""/utf8>> ->
                    {ok, Json_value};

                _ ->
                    {error,
                        create_error(
                            fun(Field@0, Field@1, Field@2) -> {unexpected_character, Field@0, Field@1, Field@2} end,
                            Json@1,
                            Rest@1,
                            <<""/utf8>>
                        )}
            end;

        {error, {unexpected_character, Char, Rest@2, -1}} ->
            {error,
                create_error(
                    fun(Field@0, Field@1, Field@2) -> {unexpected_character, Field@0, Field@1, Field@2} end,
                    Json@1,
                    Rest@2,
                    Char
                )};

        {error, {invalid_number, Num, Rest@3, -1}} ->
            {error,
                create_error(
                    fun(Field@0, Field@1, Field@2) -> {invalid_number, Field@0, Field@1, Field@2} end,
                    Json@1,
                    Rest@3,
                    Num
                )};

        {error, {invalid_character, Char@1, Rest@4, -1}} ->
            {error,
                create_error(
                    fun(Field@0, Field@1, Field@2) -> {invalid_character, Field@0, Field@1, Field@2} end,
                    Json@1,
                    Rest@4,
                    Char@1
                )};

        {error, {invalid_hex, Hex, Rest@5, -1}} ->
            {error,
                create_error(
                    fun(Field@0, Field@1, Field@2) -> {invalid_hex, Field@0, Field@1, Field@2} end,
                    Json@1,
                    Rest@5,
                    Hex
                )};

        {error, {invalid_escape_character, Esc_char, Rest@6, -1}} ->
            {error,
                create_error(
                    fun(Field@0, Field@1, Field@2) -> {invalid_escape_character, Field@0, Field@1, Field@2} end,
                    Json@1,
                    Rest@6,
                    Esc_char
                )};

        {error, _ = Parse_error} ->
            {error, Parse_error}
    end.

-file("src/simplejson/internal/parser.gleam", 281).
?DOC(false).
-spec do_parse_list(
    binary(),
    list(simplejson@jsonvalue:json_value()),
    gleam@option:option(simplejson@jsonvalue:json_value()),
    integer()
) -> {ok, {binary(), simplejson@jsonvalue:json_value()}} |
    {error, simplejson@jsonvalue:parse_error()}.
do_parse_list(Json, List, Last_value, Current_depth) ->
    gleam@bool:guard(
        Current_depth > 512,
        {error, {nesting_depth, Current_depth}},
        fun() ->
            Trimmed_json = do_trim_whitespace(Json),
            case Trimmed_json of
                <<"]"/utf8, Rest/binary>> ->
                    {ok,
                        {Rest,
                            {json_array,
                                list_to_indexed_dict(lists:reverse(List))}}};

                <<","/utf8, Rest@1/binary>> ->
                    case Last_value of
                        none ->
                            {error,
                                {invalid_character,
                                    <<","/utf8>>,
                                    Trimmed_json,
                                    -1}};

                        {some, _} ->
                            gleam@result:'try'(
                                do_parse(Rest@1, Current_depth),
                                fun(_use0) ->
                                    {Rest@2, Next_item} = _use0,
                                    do_parse_list(
                                        Rest@2,
                                        [Next_item | List],
                                        {some, Next_item},
                                        Current_depth
                                    )
                                end
                            )
                    end;

                <<""/utf8>> ->
                    {error, unexpected_end};

                _ ->
                    case Last_value of
                        none ->
                            gleam@result:'try'(
                                do_parse(Json, Current_depth),
                                fun(_use0@1) ->
                                    {Rest@3, Next_item@1} = _use0@1,
                                    do_parse_list(
                                        Rest@3,
                                        [Next_item@1 | List],
                                        {some, Next_item@1},
                                        Current_depth
                                    )
                                end
                            );

                        {some, _} ->
                            {error,
                                {unexpected_character,
                                    <<""/utf8>>,
                                    Trimmed_json,
                                    -1}}
                    end
            end
        end
    ).