-module(sketch_css@module@pipes).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/sketch_css/module/pipes.gleam").
-export([remove/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/sketch_css/module/pipes.gleam", 25).
?DOC(false).
-spec remove_statement(glance:statement()) -> glance:statement().
remove_statement(Stat) ->
    case Stat of
        {use, _, _} ->
            _record = Stat,
            {use,
                erlang:element(2, _record),
                remove_expr(erlang:element(3, Stat))};

        {expression, E} ->
            {expression, remove_expr(E)};

        {assignment, _, _, _, _} ->
            _record@1 = Stat,
            {assignment,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                erlang:element(4, _record@1),
                remove_expr(erlang:element(5, Stat))}
    end.

-file("src/sketch_css/module/pipes.gleam", 33).
?DOC(false).
-spec remove_expr(glance:expression()) -> glance:expression().
remove_expr(Expr) ->
    case Expr of
        {negate_int, Expr@1} ->
            {negate_int, remove_expr(Expr@1)};

        {negate_bool, Expr@2} ->
            {negate_bool, remove_expr(Expr@2)};

        {block, Stat} ->
            {block, gleam@list:map(Stat, fun remove_statement/1)};

        {todo, Stat@1} ->
            {todo, gleam@option:map(Stat@1, fun remove_expr/1)};

        {panic, Stat@2} ->
            {panic, gleam@option:map(Stat@2, fun remove_expr/1)};

        {tuple, Stat@3} ->
            {tuple, gleam@list:map(Stat@3, fun remove_expr/1)};

        {fn, _, _, _} ->
            _record = Expr,
            {fn,
                erlang:element(2, _record),
                erlang:element(3, _record),
                gleam@list:map(erlang:element(4, Expr), fun remove_statement/1)};

        {tuple_index, _, _} ->
            _record@1 = Expr,
            {tuple_index,
                remove_expr(erlang:element(2, Expr)),
                erlang:element(3, _record@1)};

        {list, Elements, Rest} ->
            Elements@1 = gleam@list:map(Elements, fun remove_expr/1),
            Rest@1 = gleam@option:map(Rest, fun remove_expr/1),
            {list, Elements@1, Rest@1};

        {record_update, _, _, _, _} ->
            Record = remove_expr(erlang:element(4, Expr)),
            _record@2 = Expr,
            {record_update,
                erlang:element(2, _record@2),
                erlang:element(3, _record@2),
                Record,
                begin
                    gleam@list:map(
                        erlang:element(5, Expr),
                        fun(Field) ->
                            Item = gleam@option:map(
                                erlang:element(3, Field),
                                fun remove_expr/1
                            ),
                            _record@3 = Field,
                            {record_update_field,
                                erlang:element(2, _record@3),
                                Item}
                        end
                    )
                end};

        {field_access, _, _} ->
            Container = remove_expr(erlang:element(2, Expr)),
            _record@4 = Expr,
            {field_access, Container, erlang:element(3, _record@4)};

        {call, _, _} ->
            Function = remove_expr(erlang:element(2, Expr)),
            {call,
                Function,
                begin
                    gleam@list:map(
                        erlang:element(3, Expr),
                        fun(Argument) -> remove_expr_field(Argument) end
                    )
                end};

        {'case', _, _} ->
            Subjects = gleam@list:map(
                erlang:element(2, Expr),
                fun remove_expr/1
            ),
            {'case',
                Subjects,
                begin
                    gleam@list:map(
                        erlang:element(3, Expr),
                        fun(Clause) ->
                            Guard = gleam@option:map(
                                erlang:element(3, Clause),
                                fun remove_expr/1
                            ),
                            Body = remove_expr(erlang:element(4, Clause)),
                            _record@5 = Clause,
                            {clause, erlang:element(2, _record@5), Guard, Body}
                        end
                    )
                end};

        {binary_operator, pipe, Left, {call, Function@1, Arguments}} ->
            Left@1 = {unlabelled_field, remove_expr(Left)},
            Arguments@1 = gleam@list:map(Arguments, fun remove_expr_field/1),
            Arguments@2 = [Left@1 | Arguments@1],
            {call, Function@1, Arguments@2};

        {binary_operator, pipe, Left@2, {variable, Variable}} ->
            Left@3 = {unlabelled_field, remove_expr(Left@2)},
            Arguments@3 = [Left@3],
            Function@2 = {variable, Variable},
            {call, Function@2, Arguments@3};

        {binary_operator, pipe, Left@4, Right} ->
            Left@5 = remove_expr(Left@4),
            Right@1 = remove_expr(Right),
            {call, Right@1, [{unlabelled_field, Left@5}]};

        _ ->
            Expr
    end.

-file("src/sketch_css/module/pipes.gleam", 20).
?DOC(false).
-spec remove_attribute(glance:attribute()) -> glance:attribute().
remove_attribute(Attribute) ->
    Arguments = gleam@list:map(erlang:element(3, Attribute), fun remove_expr/1),
    _record = Attribute,
    {attribute, erlang:element(2, _record), Arguments}.

-file("src/sketch_css/module/pipes.gleam", 7).
?DOC(false).
-spec remove(glance:module_()) -> glance:module_().
remove(Module) ->
    _record = Module,
    {module,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        begin
            gleam@list:map(
                erlang:element(6, Module),
                fun(_use0) ->
                    {definition, Attributes, Definition} = _use0,
                    Attributes@1 = gleam@list:map(
                        Attributes,
                        fun remove_attribute/1
                    ),
                    {definition,
                        Attributes@1,
                        begin
                            _record@1 = Definition,
                            {function,
                                erlang:element(2, _record@1),
                                erlang:element(3, _record@1),
                                erlang:element(4, _record@1),
                                erlang:element(5, _record@1),
                                begin
                                    gleam@list:map(
                                        erlang:element(6, Definition),
                                        fun(Statement) ->
                                            remove_statement(Statement)
                                        end
                                    )
                                end,
                                erlang:element(7, _record@1)}
                        end}
                end
            )
        end}.

-file("src/sketch_css/module/pipes.gleam", 109).
?DOC(false).
-spec remove_expr_field(glance:field(glance:expression())) -> glance:field(glance:expression()).
remove_expr_field(Argument) ->
    case Argument of
        {unlabelled_field, E} ->
            {unlabelled_field, remove_expr(E)};

        {shorthand_field, Label} ->
            {shorthand_field, Label};

        {labelled_field, Label@1, Item} ->
            {labelled_field, Label@1, remove_expr(Item)}
    end.