-module(simplejson@internal@query).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/simplejson/internal/query.gleam").
-export(['query'/3]).

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

?MODULEDOC(false).

-file("src/simplejson/internal/query.gleam", 78).
?DOC(false).
-spec get_descendants(
    list(simplejson@jsonvalue:json_value()),
    simplejson@jsonvalue:json_value()
) -> list(simplejson@jsonvalue:json_value()).
get_descendants(List, Json) ->
    case Json of
        {json_object, D} ->
            New_list = maps:values(D),
            gleam@list:fold(
                New_list,
                lists:append(List, New_list),
                fun get_descendants/2
            );

        {json_array, D@1} ->
            New_list@1 = maps:values(D@1),
            gleam@list:fold(
                New_list@1,
                lists:append(List, New_list@1),
                fun get_descendants/2
            );

        _ ->
            List
    end.

-file("src/simplejson/internal/query.gleam", 270).
?DOC(false).
-spec compare_items(
    gleam@order:order(),
    simplejson@internal@jsonpath:compare_op()
) -> boolean().
compare_items(Order, Op) ->
    case Op of
        eq ->
            Order =:= eq;

        gt ->
            Order =:= gt;

        gte ->
            (Order =:= gt) orelse (Order =:= eq);

        lt ->
            Order =:= lt;

        lte ->
            (Order =:= lt) orelse (Order =:= eq);

        not_eq ->
            Order /= eq
    end.

-file("src/simplejson/internal/query.gleam", 260).
?DOC(false).
-spec compare_numbers(
    bigdecimal:big_decimal(),
    bigdecimal:big_decimal(),
    simplejson@internal@jsonpath:compare_op()
) -> boolean().
compare_numbers(N1, N2, Op) ->
    Order = bigdecimal:compare(N1, N2),
    compare_items(Order, Op).

-file("src/simplejson/internal/query.gleam", 265).
?DOC(false).
-spec compare_strings(
    binary(),
    binary(),
    simplejson@internal@jsonpath:compare_op()
) -> boolean().
compare_strings(S1, S2, Op) ->
    Order = gleam@string:compare(S1, S2),
    compare_items(Order, Op).

-file("src/simplejson/internal/query.gleam", 235).
?DOC(false).
-spec compare_types(
    simplejson@internal@jsonpath:type_value(),
    simplejson@internal@jsonpath:type_value(),
    simplejson@internal@jsonpath:compare_op()
) -> boolean().
compare_types(Tv1, Tv2, Op) ->
    case {Tv1, Tv2} of
        {{value_type, {number, N1}}, {value_type, {number, N2}}} ->
            compare_numbers(N1, N2, Op);

        {{value_type, {string, S1}}, {value_type, {string, S2}}} ->
            compare_strings(S1, S2, Op);

        {{value_type, null}, {value_type, null}} ->
            compare_items(eq, Op);

        {{value_type, {boolean, B1}}, {value_type, {boolean, B2}}} ->
            case B1 =:= B2 of
                true ->
                    ((Op =:= eq) orelse (Op =:= gte)) orelse (Op =:= lte);

                false ->
                    Op =:= not_eq
            end;

        {{value_type, {array, D1}}, {value_type, {array, D2}}} ->
            D1 =:= D2;

        {{value_type, {object, D1@1}}, {value_type, {object, D2@1}}} ->
            D1@1 =:= D2@1;

        {{value_type, nothing}, {value_type, nothing}} ->
            true;

        {_, _} ->
            case Op of
                not_eq ->
                    true;

                _ ->
                    false
            end
    end.

-file("src/simplejson/internal/query.gleam", 363).
?DOC(false).
-spec do_fix_regexp(binary(), binary(), boolean()) -> binary().
do_fix_regexp(Str, New_regexp, In_class) ->
    case Str of
        <<"\\["/utf8, Rest/binary>> ->
            do_fix_regexp(Rest, <<New_regexp/binary, "\\["/utf8>>, In_class);

        <<"["/utf8, Rest@1/binary>> ->
            do_fix_regexp(Rest@1, <<New_regexp/binary, "["/utf8>>, true);

        <<"\\]"/utf8, Rest@2/binary>> ->
            do_fix_regexp(Rest@2, <<New_regexp/binary, "\\]"/utf8>>, In_class);

        <<"]"/utf8, Rest@3/binary>> ->
            do_fix_regexp(Rest@3, <<New_regexp/binary, "]"/utf8>>, false);

        <<"\\\\"/utf8, Rest@4/binary>> ->
            do_fix_regexp(Rest@4, <<New_regexp/binary, "\\\\"/utf8>>, In_class);

        <<"\\."/utf8, Rest@5/binary>> ->
            do_fix_regexp(Rest@5, <<New_regexp/binary, "\\."/utf8>>, In_class);

        <<"."/utf8, Rest@6/binary>> ->
            case In_class of
                true ->
                    do_fix_regexp(
                        Rest@6,
                        <<New_regexp/binary, "."/utf8>>,
                        In_class
                    );

                false ->
                    do_fix_regexp(
                        Rest@6,
                        <<New_regexp/binary, "[^\\n\\r]"/utf8>>,
                        In_class
                    )
            end;

        <<""/utf8>> ->
            New_regexp;

        X ->
            case gleam_stdlib:string_pop_grapheme(X) of
                {error, _} ->
                    New_regexp;

                {ok, {Char, Rest@7}} ->
                    do_fix_regexp(
                        Rest@7,
                        <<New_regexp/binary, Char/binary>>,
                        In_class
                    )
            end
    end.

-file("src/simplejson/internal/query.gleam", 357).
?DOC(false).
-spec fix_regexp(binary()) -> {ok, gleam@regexp:regexp()} | {error, nil}.
fix_regexp(Str) ->
    _pipe = gleam@regexp:from_string(do_fix_regexp(Str, <<""/utf8>>, false)),
    gleam@result:replace_error(_pipe, nil).

-file("src/simplejson/internal/query.gleam", 448).
?DOC(false).
-spec do_fn_count(simplejson@internal@jsonpath:type_value()) -> simplejson@internal@jsonpath:type_value().
do_fn_count(Arg) ->
    case Arg of
        {value_type, _} ->
            {value_type, nothing};

        {logical_type, _} ->
            {value_type, nothing};

        {nodes_type, L} ->
            _pipe = erlang:length(L),
            _pipe@1 = erlang:float(_pipe),
            _pipe@2 = bigdecimal:from_float(_pipe@1),
            _pipe@3 = {number, _pipe@2},
            {value_type, _pipe@3}
    end.

-file("src/simplejson/internal/query.gleam", 519).
?DOC(false).
-spec jsonvalue_to_literal(simplejson@jsonvalue:json_value()) -> simplejson@internal@jsonpath:literal().
jsonvalue_to_literal(Jv) ->
    case Jv of
        {json_array, Arr} ->
            {array, Arr};

        {json_object, Obj} ->
            {object, Obj};

        {json_bool, Bool} ->
            {boolean, Bool};

        json_null ->
            null;

        {json_number, {some, I}, _, _} ->
            Bd@1 = case bigdecimal:from_string(erlang:integer_to_binary(I)) of
                {ok, Bd} -> Bd;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"simplejson/internal/query"/utf8>>,
                                function => <<"jsonvalue_to_literal"/utf8>>,
                                line => 526,
                                value => _assert_fail,
                                start => 14724,
                                'end' => 14784,
                                pattern_start => 14735,
                                pattern_end => 14741})
            end,
            {number, Bd@1};

        {json_number, _, _, {some, S}} ->
            N@1 = case simplejson@internal@jsonpath:parse_literal_number(S) of
                {ok, {N, _}} -> N;
                _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/query"/utf8>>,
                                function => <<"jsonvalue_to_literal"/utf8>>,
                                line => 530,
                                value => _assert_fail@1,
                                start => 14871,
                                'end' => 14928,
                                pattern_start => 14882,
                                pattern_end => 14893})
            end,
            N@1;

        {json_number, _, {some, F}, _} ->
            {number, bigdecimal:from_float(F)};

        {json_string, Str} ->
            {string, Str};

        {json_number, none, none, none} ->
            {number, bigdecimal:zero()}
    end.

-file("src/simplejson/internal/query.gleam", 387).
?DOC(false).
-spec do_fn_match(
    simplejson@internal@jsonpath:type_value(),
    simplejson@internal@jsonpath:type_value()
) -> {ok, simplejson@internal@jsonpath:type_value()} | {error, nil}.
do_fn_match(Arg1, Arg2) ->
    case {Arg1, Arg2} of
        {{value_type, {string, S}}, {value_type, {string, S2}}} ->
            gleam@result:'try'(
                fix_regexp(<<<<"^"/utf8, S2/binary>>/binary, "$"/utf8>>),
                fun(Regex) ->
                    _pipe = {logical_type, gleam@regexp:check(Regex, S)},
                    {ok, _pipe}
                end
            );

        {{nodes_type, [V1]}, {nodes_type, [V2]}} ->
            do_fn_match(
                {value_type, jsonvalue_to_literal(V1)},
                {value_type, jsonvalue_to_literal(V2)}
            );

        {{nodes_type, [V]}, _} ->
            do_fn_match({value_type, jsonvalue_to_literal(V)}, Arg2);

        {_, {nodes_type, [V@1]}} ->
            do_fn_match(Arg1, {value_type, jsonvalue_to_literal(V@1)});

        {_, _} ->
            _pipe@1 = {logical_type, false},
            {ok, _pipe@1}
    end.

-file("src/simplejson/internal/query.gleam", 410).
?DOC(false).
-spec do_fn_search(
    simplejson@internal@jsonpath:type_value(),
    simplejson@internal@jsonpath:type_value()
) -> {ok, simplejson@internal@jsonpath:type_value()} | {error, nil}.
do_fn_search(Arg1, Arg2) ->
    case {Arg1, Arg2} of
        {{value_type, {string, S}}, {value_type, {string, S2}}} ->
            gleam@result:'try'(
                fix_regexp(S2),
                fun(Regex) ->
                    _pipe = {logical_type, gleam@regexp:check(Regex, S)},
                    {ok, _pipe}
                end
            );

        {{nodes_type, [V1]}, {nodes_type, [V2]}} ->
            do_fn_search(
                {value_type, jsonvalue_to_literal(V1)},
                {value_type, jsonvalue_to_literal(V2)}
            );

        {{nodes_type, [V]}, _} ->
            do_fn_search({value_type, jsonvalue_to_literal(V)}, Arg2);

        {_, {nodes_type, [V@1]}} ->
            do_fn_search(Arg1, {value_type, jsonvalue_to_literal(V@1)});

        {_, _} ->
            _pipe@1 = {logical_type, false},
            {ok, _pipe@1}
    end.

-file("src/simplejson/internal/query.gleam", 433).
?DOC(false).
-spec do_fn_value(simplejson@internal@jsonpath:type_value()) -> simplejson@internal@jsonpath:type_value().
do_fn_value(Arg) ->
    case Arg of
        {value_type, _} ->
            {value_type, nothing};

        {logical_type, _} ->
            {value_type, nothing};

        {nodes_type, L} ->
            case L of
                [V] ->
                    {value_type, jsonvalue_to_literal(V)};

                _ ->
                    {value_type, nothing}
            end
    end.

-file("src/simplejson/internal/query.gleam", 461).
?DOC(false).
-spec do_fn_length(simplejson@internal@jsonpath:type_value()) -> simplejson@internal@jsonpath:type_value().
do_fn_length(Arg) ->
    case Arg of
        {value_type, {string, S}} ->
            _pipe = string:length(S),
            _pipe@1 = erlang:float(_pipe),
            _pipe@2 = bigdecimal:from_float(_pipe@1),
            _pipe@3 = {number, _pipe@2},
            {value_type, _pipe@3};

        {value_type, {array, A}} ->
            _pipe@4 = maps:size(A),
            _pipe@5 = erlang:float(_pipe@4),
            _pipe@6 = bigdecimal:from_float(_pipe@5),
            _pipe@7 = {number, _pipe@6},
            {value_type, _pipe@7};

        {value_type, {boolean, _}} ->
            {value_type, nothing};

        {value_type, nothing} ->
            {value_type, nothing};

        {value_type, null} ->
            {value_type, nothing};

        {value_type, {number, _}} ->
            {value_type, nothing};

        {value_type, {object, O}} ->
            _pipe@8 = maps:size(O),
            _pipe@9 = erlang:float(_pipe@8),
            _pipe@10 = bigdecimal:from_float(_pipe@9),
            _pipe@11 = {number, _pipe@10},
            {value_type, _pipe@11};

        {logical_type, _} ->
            {value_type, nothing};

        {nodes_type, [L]} ->
            do_fn_length({value_type, jsonvalue_to_literal(L)});

        {nodes_type, _} ->
            {value_type, nothing}
    end.

-file("src/simplejson/internal/query.gleam", 548).
?DOC(false).
-spec map_singular_query_to_query(
    list(simplejson@internal@jsonpath:singular_segment())
) -> list(simplejson@internal@jsonpath:segment()).
map_singular_query_to_query(Sq) ->
    gleam@list:map(Sq, fun(Segment) -> case Segment of
                {single_index, I} ->
                    {child, [{index, I}]};

                {single_name, N} ->
                    {child, [{name, N}]}
            end end).

-file("src/simplejson/internal/query.gleam", 635).
?DOC(false).
-spec normalise(integer(), integer()) -> integer().
normalise(I, Len) ->
    case I >= 0 of
        true ->
            I;

        false ->
            Len + I
    end.

-file("src/simplejson/internal/query.gleam", 617).
?DOC(false).
-spec get_bounds(integer(), integer(), integer(), integer()) -> {integer(),
    integer()}.
get_bounds(Start, End, Step, Len) ->
    Start@1 = normalise(Start, Len),
    End@1 = normalise(End, Len),
    case Step >= 0 of
        true ->
            Lower = gleam@int:min(gleam@int:max(Start@1, 0), Len),
            Upper = gleam@int:min(gleam@int:max(End@1, 0), Len),
            {Lower, Upper};

        false ->
            Upper@1 = gleam@int:min(gleam@int:max(Start@1, -1), Len - 1),
            Lower@1 = gleam@int:min(gleam@int:max(End@1, -1), Len - 1),
            {Upper@1, Lower@1}
    end.

-file("src/simplejson/internal/query.gleam", 557).
?DOC(false).
-spec do_slice(
    simplejson@jsonvalue:json_value(),
    gleam@option:option(integer()),
    gleam@option:option(integer()),
    gleam@option:option(integer())
) -> list(simplejson@jsonvalue:json_value()).
do_slice(Json, Start, End, Step) ->
    case Json of
        {json_array, D} ->
            gleam@bool:guard(
                Step =:= {some, 0},
                [],
                fun() ->
                    Len = maps:size(D),
                    Step@1 = gleam@option:unwrap(Step, 1),
                    Start@1 = gleam@option:lazy_unwrap(
                        Start,
                        fun() -> case Step@1 >= 0 of
                                true ->
                                    0;

                                false ->
                                    Len - 1
                            end end
                    ),
                    End@1 = gleam@option:lazy_unwrap(
                        End,
                        fun() -> case Step@1 >= 0 of
                                true ->
                                    Len;

                                false ->
                                    - Len - 1
                            end end
                    ),
                    {Start@2, End@2} = get_bounds(Start@1, End@1, Step@1, Len),
                    Yielder = gleam@yielder:unfold(
                        Start@2,
                        fun(Acc) -> case gleam@int:compare(Step@1, 0) of
                                gt ->
                                    case Acc < End@2 of
                                        true ->
                                            {next, Acc, Acc + Step@1};

                                        false ->
                                            done
                                    end;

                                lt ->
                                    case Acc > End@2 of
                                        true ->
                                            {next, Acc, Acc + Step@1};

                                        false ->
                                            done
                                    end;

                                eq ->
                                    done
                            end end
                    ),
                    L@1 = gleam@yielder:fold(
                        Yielder,
                        [],
                        fun(L, Index) -> case gleam_stdlib:map_get(D, Index) of
                                {error, _} ->
                                    L;

                                {ok, V} ->
                                    [V | L]
                            end end
                    ),
                    lists:reverse(L@1)
                end
            );

        _ ->
            []
    end.

-file("src/simplejson/internal/query.gleam", 642).
?DOC(false).
-spec do_index(simplejson@jsonvalue:json_value(), integer()) -> list(simplejson@jsonvalue:json_value()).
do_index(Json, Index) ->
    case Json of
        {json_array, D} ->
            case Index >= 0 of
                true ->
                    case gleam_stdlib:map_get(D, Index) of
                        {ok, J} ->
                            [J];

                        _ ->
                            []
                    end;

                false ->
                    Index@1 = maps:size(D) + Index,
                    case Index@1 < 0 of
                        true ->
                            [];

                        false ->
                            case gleam_stdlib:map_get(D, Index@1) of
                                {ok, J@1} ->
                                    [J@1];

                                _ ->
                                    []
                            end
                    end
            end;

        _ ->
            []
    end.

-file("src/simplejson/internal/query.gleam", 670).
?DOC(false).
-spec do_wildcard(simplejson@jsonvalue:json_value()) -> list(simplejson@jsonvalue:json_value()).
do_wildcard(Json) ->
    case Json of
        {json_array, D} ->
            simplejson@internal@stringify:dict_to_ordered_list(D);

        {json_object, D@1} ->
            maps:values(D@1);

        _ ->
            []
    end.

-file("src/simplejson/internal/query.gleam", 678).
?DOC(false).
-spec do_name(simplejson@jsonvalue:json_value(), binary()) -> list(simplejson@jsonvalue:json_value()).
do_name(Json, Name) ->
    case Json of
        {json_object, D} ->
            case gleam_stdlib:map_get(D, Name) of
                {ok, V} ->
                    [V];

                _ ->
                    []
            end;

        _ ->
            []
    end.

-file("src/simplejson/internal/query.gleam", 142).
?DOC(false).
-spec do_logical_expr(
    simplejson@jsonvalue:json_value(),
    simplejson@internal@jsonpath:logical_expression(),
    simplejson@jsonvalue:json_value()
) -> {ok, boolean()} | {error, nil}.
do_logical_expr(Json, Expr, Absroot) ->
    gleam@list:fold_until(
        erlang:element(2, erlang:element(2, Expr)),
        {ok, false},
        fun(_, And_expr) ->
            case gleam@list:fold_until(
                erlang:element(2, And_expr),
                {ok, true},
                fun(_, Expr@1) -> case Expr@1 of
                        {comparison, Cmp1, Cmp2, Cmpop} ->
                            case do_comparison(Json, Cmp1, Cmp2, Cmpop, Absroot) of
                                {ok, true} ->
                                    {continue, {ok, true}};

                                {ok, false} ->
                                    {stop, {ok, false}};

                                {error, _} ->
                                    {stop, {error, nil}}
                            end;

                        {paren, Expr@2, Not} ->
                            case do_logical_expr(Json, Expr@2, Absroot) of
                                {error, _} ->
                                    {stop, {error, nil}};

                                {ok, true} ->
                                    {continue, {ok, case Not of
                                                true ->
                                                    false;

                                                false ->
                                                    true
                                            end}};

                                {ok, false} ->
                                    {stop, {ok, case Not of
                                                true ->
                                                    true;

                                                false ->
                                                    false
                                            end}}
                            end;

                        {test, Expr@3, Not@1} ->
                            case Expr@3 of
                                {filter_query, Fq} ->
                                    {Root, Path@2} = case Fq of
                                        {relative, Path} ->
                                            {Json, Path};

                                        {root, Path@1} ->
                                            {Absroot, Path@1}
                                    end,
                                    case query_to_list(Root, Path@2, Absroot) of
                                        {ok, L} ->
                                            case {gleam@list:is_empty(L), Not@1} of
                                                {true, false} ->
                                                    {stop, {ok, false}};

                                                {false, false} ->
                                                    {continue, {ok, true}};

                                                {false, true} ->
                                                    {stop, {ok, false}};

                                                {true, true} ->
                                                    {continue, {ok, true}}
                                            end;

                                        {error, _} ->
                                            {stop, {error, nil}}
                                    end;

                                {function_expr, Fe} ->
                                    case run_function(Json, Fe, Absroot) of
                                        {ok, {logical_type, Cmp}} ->
                                            Cmp@1 = case Not@1 of
                                                false ->
                                                    Cmp;

                                                true ->
                                                    not Cmp
                                            end,
                                            case Cmp@1 of
                                                true ->
                                                    {continue, {ok, true}};

                                                false ->
                                                    {stop, {ok, false}}
                                            end;

                                        _ ->
                                            {stop, {error, nil}}
                                    end
                            end
                    end end
            ) of
                {error, _} ->
                    {stop, {error, nil}};

                {ok, true} ->
                    {stop, {ok, true}};

                {ok, false} ->
                    {continue, {ok, false}}
            end
        end
    ).

-file("src/simplejson/internal/query.gleam", 281).
?DOC(false).
-spec run_function(
    simplejson@jsonvalue:json_value(),
    simplejson@internal@jsonpath:function_(),
    simplejson@jsonvalue:json_value()
) -> {ok, simplejson@internal@jsonpath:type_value()} | {error, nil}.
run_function(Root, F, Absroot) ->
    {function, Deffn, Args} = F,
    gleam@result:'try'(gleam@list:try_map(Args, fun(A) -> case A of
                    {function_arg, Fa} ->
                        run_function(Root, Fa, Absroot);

                    {literal_arg, L} ->
                        {ok, {value_type, L}};

                    {logical_arg, La} ->
                        case do_logical_expr(Root, La, Absroot) of
                            {ok, Lt} ->
                                {ok, {logical_type, Lt}};

                            {error, _} ->
                                {error, nil}
                        end;

                    {query_arg, Qa} ->
                        {Root@1, Qa@1} = case Qa of
                            {root, Sq} ->
                                {Absroot, Sq};

                            {relative, Sq@1} ->
                                {Root, Sq@1}
                        end,
                        case query_to_list(Root@1, Qa@1, Absroot) of
                            {ok, L@1} ->
                                {ok, {nodes_type, L@1}};

                            {error, _} ->
                                {error, nil}
                        end;

                    {query_singular_arg, Qa@2} ->
                        {Root@2, Qa@3} = case Qa@2 of
                            {root, Sq@2} ->
                                {Absroot, Sq@2};

                            {relative, Sq@3} ->
                                {Root, Sq@3}
                        end,
                        case query_to_list(Root@2, Qa@3, Absroot) of
                            {ok, [V]} ->
                                {ok, {nodes_type, [V]}};

                            {ok, _} ->
                                {ok, {value_type, nothing}};

                            {error, _} ->
                                {error, nil}
                        end
                end end), fun(Args@1) -> case Deffn of
                count ->
                    case Args@1 of
                        [Arg] ->
                            {ok, do_fn_count(Arg)};

                        _ ->
                            {error, nil}
                    end;

                length ->
                    case Args@1 of
                        [Arg@1] ->
                            {ok, do_fn_length(Arg@1)};

                        _ ->
                            {error, nil}
                    end;

                match ->
                    case Args@1 of
                        [A1, A2] ->
                            do_fn_match(A1, A2);

                        _ ->
                            {error, nil}
                    end;

                search ->
                    case Args@1 of
                        [A1@1, A2@1] ->
                            do_fn_search(A1@1, A2@1);

                        _ ->
                            {error, nil}
                    end;

                {unknown, _} ->
                    {ok, {value_type, nothing}};

                value_of ->
                    case Args@1 of
                        [Arg@2] ->
                            {ok, do_fn_value(Arg@2)};

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

-file("src/simplejson/internal/query.gleam", 119).
?DOC(false).
-spec do_filter(
    simplejson@jsonvalue:json_value(),
    simplejson@internal@jsonpath:logical_expression(),
    simplejson@jsonvalue:json_value()
) -> {ok, list(simplejson@jsonvalue:json_value())} | {error, nil}.
do_filter(Json, Expr, Absroot) ->
    L = case Json of
        {json_array, D} ->
            simplejson@internal@stringify:dict_to_ordered_list(D);

        {json_object, D@1} ->
            maps:values(D@1);

        _ ->
            []
    end,
    gleam@bool:guard(
        L =:= [],
        {ok, []},
        fun() ->
            _pipe = gleam@list:try_fold(
                L,
                [],
                fun(Res, Json@1) ->
                    case do_logical_expr(Json@1, Expr, Absroot) of
                        {ok, true} ->
                            {ok, [Json@1 | Res]};

                        {ok, false} ->
                            {ok, Res};

                        {error, _} ->
                            {error, nil}
                    end
                end
            ),
            gleam@result:map(_pipe, fun lists:reverse/1)
        end
    ).

-file("src/simplejson/internal/query.gleam", 105).
?DOC(false).
-spec do_selector(
    simplejson@jsonvalue:json_value(),
    simplejson@internal@jsonpath:selector(),
    simplejson@jsonvalue:json_value()
) -> {ok, list(simplejson@jsonvalue:json_value())} | {error, nil}.
do_selector(Json, Selector, Absroot) ->
    case Selector of
        {filter, Expr} ->
            do_filter(Json, Expr, Absroot);

        {index, I} ->
            {ok, do_index(Json, I)};

        {name, Name} ->
            {ok, do_name(Json, Name)};

        {slice, Start, End, Step} ->
            {ok, do_slice(Json, Start, End, Step)};

        wildcard ->
            {ok, do_wildcard(Json)}
    end.

-file("src/simplejson/internal/query.gleam", 92).
?DOC(false).
-spec do_checks(
    simplejson@jsonvalue:json_value(),
    list(simplejson@internal@jsonpath:selector()),
    simplejson@jsonvalue:json_value()
) -> {ok, list(simplejson@jsonvalue:json_value())} | {error, nil}.
do_checks(Json, Selectors, Absroot) ->
    gleam@list:try_fold(
        Selectors,
        [],
        fun(List, Selector) -> case do_selector(Json, Selector, Absroot) of
                {ok, Found} ->
                    {ok, lists:append(List, Found)};

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

-file("src/simplejson/internal/query.gleam", 65).
?DOC(false).
-spec process_selectors(
    list(simplejson@internal@jsonpath:selector()),
    list(simplejson@jsonvalue:json_value()),
    simplejson@jsonvalue:json_value()
) -> {ok, list(simplejson@jsonvalue:json_value())} | {error, nil}.
process_selectors(Selectors, Nodes, Absroot) ->
    gleam@list:try_fold(
        Nodes,
        [],
        fun(Arr, Node) -> case do_checks(Node, Selectors, Absroot) of
                {ok, Found} ->
                    {ok, lists:append(Arr, Found)};

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

-file("src/simplejson/internal/query.gleam", 47).
?DOC(false).
-spec do_query(
    list(simplejson@jsonvalue:json_value()),
    simplejson@internal@jsonpath:segment(),
    simplejson@jsonvalue:json_value()
) -> {ok, list(simplejson@jsonvalue:json_value())} | {error, nil}.
do_query(Json, Segment, Absroot) ->
    gleam@list:try_fold(
        Json,
        [],
        fun(Acc, J) ->
            Processed = case Segment of
                {child, Selectors} ->
                    process_selectors(Selectors, [J], Absroot);

                {descendant, Selectors@1} ->
                    process_selectors(
                        Selectors@1,
                        get_descendants([J], J),
                        Absroot
                    )
            end,
            case Processed of
                {ok, Results} ->
                    {ok, lists:append(Acc, Results)};

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

-file("src/simplejson/internal/query.gleam", 37).
?DOC(false).
-spec query_to_list(
    simplejson@jsonvalue:json_value(),
    list(simplejson@internal@jsonpath:segment()),
    simplejson@jsonvalue:json_value()
) -> {ok, list(simplejson@jsonvalue:json_value())} | {error, nil}.
query_to_list(Json, Path, Absroot) ->
    gleam@list:try_fold(
        Path,
        [Json],
        fun(Acc, Segment) -> do_query(Acc, Segment, Absroot) end
    ).

-file("src/simplejson/internal/query.gleam", 27).
?DOC(false).
-spec 'query'(
    simplejson@jsonvalue:json_value(),
    list(simplejson@internal@jsonpath:segment()),
    simplejson@jsonvalue:json_value()
) -> simplejson@jsonvalue:json_value().
'query'(Json, Path, Absroot) ->
    case query_to_list(Json, Path, Absroot) of
        {error, _} ->
            {json_array, maps:new()};

        {ok, L} ->
            _pipe = L,
            _pipe@1 = simplejson@internal@parser:list_to_indexed_dict(_pipe),
            {json_array, _pipe@1}
    end.

-file("src/simplejson/internal/query.gleam", 492).
?DOC(false).
-spec get_comparable(
    simplejson@jsonvalue:json_value(),
    simplejson@internal@jsonpath:comparable(),
    simplejson@jsonvalue:json_value()
) -> {ok, simplejson@internal@jsonpath:type_value()} | {error, nil}.
get_comparable(Root, Cmp, Absroot) ->
    case Cmp of
        {function_expr_cmp, F} ->
            run_function(Root, F, Absroot);

        {literal, L} ->
            {ok, {value_type, L}};

        {query_cmp, Sq} ->
            {Root@1, Sq@3} = case Sq of
                {abs_query, Sq@1} ->
                    {Absroot, Sq@1};

                {rel_query, Sq@2} ->
                    {Root, Sq@2}
            end,
            Jp = map_singular_query_to_query(Sq@3),
            case query_to_list(Root@1, Jp, Absroot) of
                {ok, [V]} ->
                    {ok, {value_type, jsonvalue_to_literal(V)}};

                {ok, []} ->
                    {ok, {value_type, nothing}};

                _ ->
                    {error, nil}
            end
    end.

-file("src/simplejson/internal/query.gleam", 223).
?DOC(false).
-spec do_comparison(
    simplejson@jsonvalue:json_value(),
    simplejson@internal@jsonpath:comparable(),
    simplejson@internal@jsonpath:comparable(),
    simplejson@internal@jsonpath:compare_op(),
    simplejson@jsonvalue:json_value()
) -> {ok, boolean()} | {error, nil}.
do_comparison(Root, Cmp1, Cmp2, Op, Absroot) ->
    gleam@result:'try'(
        get_comparable(Root, Cmp1, Absroot),
        fun(Cmp1@1) ->
            gleam@result:'try'(
                get_comparable(Root, Cmp2, Absroot),
                fun(Cmp2@1) -> {ok, compare_types(Cmp1@1, Cmp2@1, Op)} end
            )
        end
    ).