-module(pearl).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/pearl.gleam").
-export([new/1, ignore_comments/1, ignore_whitespace/1, to_source/1, tokenise/1]).
-export_type([lexer/0, splitters/0, error/0, lex_number_mode/0, delimited_position/0]).

-opaque lexer() :: {lexer,
        binary(),
        boolean(),
        boolean(),
        list(error()),
        splitters()}.

-type splitters() :: {splitters,
        splitter:splitter(),
        splitter:splitter(),
        splitter:splitter(),
        splitter:splitter(),
        splitter:splitter(),
        splitter:splitter(),
        splitter:splitter()}.

-type error() :: {unknown_character, binary()} |
    unterminated_string |
    unterminated_atom |
    {invalid_radix, binary()} |
    numeric_separator_not_allowed |
    expected_exponent |
    number_cannot_end_after_radix |
    unterminated_character |
    unterminated_escape_sequence |
    expected_sigil_delimiter |
    expected_whitespace_after_triple_quote |
    {invalid_triple_quoted_string_indentation, binary(), binary()}.

-type lex_number_mode() :: initial | {radix, integer()} | decimal | exponent.

-type delimited_position() :: after_decimal |
    after_number |
    after_separator |
    after_exponent |
    after_radix.

-file("src/pearl.gleam", 58).
-spec make_splitters() -> splitters().
make_splitters() ->
    {splitters,
        splitter:new([<<"\n"/utf8>>, <<"\r\n"/utf8>>]),
        splitter:new([<<"\""/utf8>>, <<"\\"/utf8>>]),
        splitter:new([<<"'"/utf8>>, <<"\\"/utf8>>]),
        splitter:new([<<"}"/utf8>>, <<"\n"/utf8>>, <<"\r\n"/utf8>>]),
        splitter:new(
            [<<")"/utf8>>,
                <<"]"/utf8>>,
                <<"}"/utf8>>,
                <<">"/utf8>>,
                <<"/"/utf8>>,
                <<"|"/utf8>>,
                <<"'"/utf8>>,
                <<"\""/utf8>>,
                <<"`"/utf8>>,
                <<"#"/utf8>>,
                <<"\\"/utf8>>]
        ),
        splitter:new(
            [<<")"/utf8>>,
                <<"]"/utf8>>,
                <<"}"/utf8>>,
                <<">"/utf8>>,
                <<"/"/utf8>>,
                <<"|"/utf8>>,
                <<"'"/utf8>>,
                <<"\""/utf8>>,
                <<"`"/utf8>>,
                <<"#"/utf8>>]
        ),
        splitter:new([<<"\n"/utf8>>, <<"\r\n"/utf8>>, <<"\"\"\""/utf8>>])}.

-file("src/pearl.gleam", 48).
-spec new(binary()) -> lexer().
new(Source) ->
    {lexer, Source, false, false, [], make_splitters()}.

-file("src/pearl.gleam", 74).
-spec ignore_comments(lexer()) -> lexer().
ignore_comments(Lexer) ->
    {lexer,
        erlang:element(2, Lexer),
        true,
        erlang:element(4, Lexer),
        erlang:element(5, Lexer),
        erlang:element(6, Lexer)}.

-file("src/pearl.gleam", 78).
-spec ignore_whitespace(lexer()) -> lexer().
ignore_whitespace(Lexer) ->
    {lexer,
        erlang:element(2, Lexer),
        erlang:element(3, Lexer),
        true,
        erlang:element(5, Lexer),
        erlang:element(6, Lexer)}.

-file("src/pearl.gleam", 86).
-spec to_source(list(pearl@token:token())) -> binary().
to_source(Tokens) ->
    gleam@list:fold(
        Tokens,
        <<""/utf8>>,
        fun(Code, Token) ->
            <<Code/binary, (pearl@token:to_source(Token))/binary>>
        end
    ).

-file("src/pearl.gleam", 779).
-spec is_whitespace(binary()) -> boolean().
is_whitespace(String) ->
    case String of
        <<""/utf8>> ->
            true;

        <<" "/utf8, String@1/binary>> ->
            is_whitespace(String@1);

        <<"\n"/utf8, String@1/binary>> ->
            is_whitespace(String@1);

        <<"\r"/utf8, String@1/binary>> ->
            is_whitespace(String@1);

        <<"\t"/utf8, String@1/binary>> ->
            is_whitespace(String@1);

        <<"\f"/utf8, String@1/binary>> ->
            is_whitespace(String@1);

        _ ->
            false
    end.

-file("src/pearl.gleam", 791).
-spec strip_line_prefixes(list(binary()), binary(), list(binary())) -> {ok,
        list(binary())} |
    {error, binary()}.
strip_line_prefixes(Lines, End_indentation, Acc) ->
    case Lines of
        [] ->
            {ok, Acc};

        [Line | Lines@1] ->
            case pearl_ffi:strip_prefix(Line, End_indentation) of
                {ok, Line@1} ->
                    strip_line_prefixes(
                        Lines@1,
                        End_indentation,
                        [Line@1 | Acc]
                    );

                {error, _} ->
                    {error, Line}
            end
    end.

-file("src/pearl.gleam", 1035).
-spec advance(lexer(), binary()) -> lexer().
advance(Lexer, Source) ->
    {lexer,
        Source,
        erlang:element(3, Lexer),
        erlang:element(4, Lexer),
        erlang:element(5, Lexer),
        erlang:element(6, Lexer)}.

-file("src/pearl.gleam", 364).
-spec extract_octal_digit(lexer()) -> {ok, {lexer(), binary()}} | {error, nil}.
extract_octal_digit(Lexer) ->
    case erlang:element(2, Lexer) of
        <<Char:1/binary, Source/binary>> when Char =:= <<"0"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"1"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"2"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"3"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"4"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"5"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"6"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"7"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        _ ->
            {error, nil}
    end.

-file("src/pearl.gleam", 353).
-spec lex_octal_escape_sequence(lexer(), binary()) -> {lexer(), binary()}.
lex_octal_escape_sequence(Lexer, First) ->
    case extract_octal_digit(Lexer) of
        {error, _} ->
            {Lexer, First};

        {ok, {Lexer@1, Second}} ->
            case extract_octal_digit(Lexer@1) of
                {error, _} ->
                    {Lexer@1, <<First/binary, Second/binary>>};

                {ok, {Lexer@2, Third}} ->
                    {Lexer@2,
                        <<<<First/binary, Second/binary>>/binary, Third/binary>>}
            end
    end.

-file("src/pearl.gleam", 389).
-spec extract_hex_digit(lexer()) -> {ok, {lexer(), binary()}} | {error, nil}.
extract_hex_digit(Lexer) ->
    case erlang:element(2, Lexer) of
        <<Char:1/binary, Source/binary>> when Char =:= <<"0"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"1"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"2"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"3"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"4"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"5"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"6"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"7"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"8"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"9"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"a"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"b"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"c"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"d"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"e"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"f"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"A"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"B"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"C"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"D"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"E"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        <<Char:1/binary, Source/binary>> when Char =:= <<"F"/utf8>> ->
            {ok, {advance(Lexer, Source), Char}};

        _ ->
            {error, nil}
    end.

-file("src/pearl.gleam", 772).
-spec count_extra_quotes(lexer(), integer()) -> {lexer(), integer()}.
count_extra_quotes(Lexer, Extra) ->
    case erlang:element(2, Lexer) of
        <<"\""/utf8, Source/binary>> ->
            count_extra_quotes(advance(Lexer, Source), Extra + 1);

        _ ->
            {Lexer, Extra}
    end.

-file("src/pearl.gleam", 859).
-spec consume_extra_quotes(lexer(), integer()) -> {ok, lexer()} | {error, nil}.
consume_extra_quotes(Lexer, Extra_quotes) ->
    case {Extra_quotes, erlang:element(2, Lexer)} of
        {0, _} ->
            {ok, Lexer};

        {_, <<"\""/utf8, Source/binary>>} ->
            consume_extra_quotes(advance(Lexer, Source), Extra_quotes - 1);

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

-file("src/pearl.gleam", 894).
-spec lex_variable_or_atom(lexer(), binary()) -> {lexer(), binary()}.
lex_variable_or_atom(Lexer, Lexed) ->
    case erlang:element(2, Lexer) of
        <<Char:1/binary, Source/binary>> when Char =:= <<"a"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"b"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"c"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"d"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"e"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"f"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"g"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"h"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"i"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"j"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"k"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"l"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"m"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"n"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"o"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"p"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"q"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"r"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"s"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"t"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"u"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"v"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"w"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"x"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"y"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"z"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"A"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"B"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"C"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"D"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"E"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"F"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"G"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"H"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"I"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"J"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"K"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"L"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"M"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"N"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"O"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"P"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"Q"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"R"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"S"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"T"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"U"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"V"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"W"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"X"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"Y"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"Z"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"0"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"1"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"2"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"3"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"4"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"5"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"6"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"7"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"8"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"9"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"_"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"@"/utf8>> ->
            lex_variable_or_atom(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>
            );

        _ ->
            {Lexer, Lexed}
    end.

-file("src/pearl.gleam", 966).
-spec lex_variable(lexer(), binary()) -> {lexer(), pearl@token:token()}.
lex_variable(Lexer, Char) ->
    {Lexer@1, Name} = lex_variable_or_atom(Lexer, Char),
    {Lexer@1, {variable, Name}}.

-file("src/pearl.gleam", 971).
-spec lex_atom(lexer(), binary()) -> {lexer(), pearl@token:token()}.
lex_atom(Lexer, Char) ->
    {Lexer@1, Name} = lex_variable_or_atom(Lexer, Char),
    Token = case Name of
        <<"after"/utf8>> ->
            'after';

        <<"begin"/utf8>> ->
            'begin';

        <<"case"/utf8>> ->
            'case';

        <<"catch"/utf8>> ->
            'catch';

        <<"cond"/utf8>> ->
            'cond';

        <<"else"/utf8>> ->
            'else';

        <<"end"/utf8>> ->
            'end';

        <<"fun"/utf8>> ->
            'fun';

        <<"if"/utf8>> ->
            'if';

        <<"let"/utf8>> ->
            'let';

        <<"maybe"/utf8>> ->
            'maybe';

        <<"of"/utf8>> ->
            'of';

        <<"receive"/utf8>> ->
            'receive';

        <<"try"/utf8>> ->
            'try';

        <<"when"/utf8>> ->
            'when';

        <<"bnot"/utf8>> ->
            'bnot';

        <<"div"/utf8>> ->
            'div';

        <<"rem"/utf8>> ->
            'rem';

        <<"band"/utf8>> ->
            'band';

        <<"bor"/utf8>> ->
            'bor';

        <<"bxor"/utf8>> ->
            'bxor';

        <<"bsl"/utf8>> ->
            'bsl';

        <<"bsr"/utf8>> ->
            'bsr';

        <<"not"/utf8>> ->
            'not';

        <<"and"/utf8>> ->
            'and';

        <<"or"/utf8>> ->
            'or';

        <<"xor"/utf8>> ->
            'xor';

        <<"andalso"/utf8>> ->
            'andalso';

        <<"orelse"/utf8>> ->
            'orelse';

        _ ->
            {atom, Name, false}
    end,
    {Lexer@1, Token}.

-file("src/pearl.gleam", 1010).
-spec lex_until_end_of_line(lexer()) -> {lexer(), binary()}.
lex_until_end_of_line(Lexer) ->
    {Before, Split, After} = splitter_ffi:split(
        erlang:element(2, erlang:element(6, Lexer)),
        erlang:element(2, Lexer)
    ),
    {advance(Lexer, <<Split/binary, After/binary>>), Before}.

-file("src/pearl.gleam", 1039).
-spec error(lexer(), error()) -> lexer().
error(Lexer, Error) ->
    {lexer,
        erlang:element(2, Lexer),
        erlang:element(3, Lexer),
        erlang:element(4, Lexer),
        [Error | erlang:element(5, Lexer)],
        erlang:element(6, Lexer)}.

-file("src/pearl.gleam", 378).
-spec lex_hex_escape_sequence(lexer()) -> {lexer(), binary()}.
lex_hex_escape_sequence(Lexer) ->
    case extract_hex_digit(Lexer) of
        {error, _} ->
            {error(Lexer, unterminated_escape_sequence), <<"x"/utf8>>};

        {ok, {Lexer@1, First}} ->
            case extract_hex_digit(Lexer@1) of
                {error, _} ->
                    {error(Lexer@1, unterminated_escape_sequence),
                        <<"x"/utf8, First/binary>>};

                {ok, {Lexer@2, Second}} ->
                    {Lexer@2,
                        <<<<"x"/utf8, First/binary>>/binary, Second/binary>>}
            end
    end.

-file("src/pearl.gleam", 417).
-spec lex_brace_escape_sequence(lexer()) -> {lexer(), binary()}.
lex_brace_escape_sequence(Lexer) ->
    case splitter_ffi:split(
        erlang:element(5, erlang:element(6, Lexer)),
        erlang:element(2, Lexer)
    ) of
        {Before, <<"}"/utf8>>, After} ->
            {advance(Lexer, After),
                <<<<"x{"/utf8, Before/binary>>/binary, "}"/utf8>>};

        {Before@1, Separator, After@1} ->
            {advance(
                    error(Lexer, unterminated_escape_sequence),
                    <<Separator/binary, After@1/binary>>
                ),
                <<"x{"/utf8, Before@1/binary>>}
    end.

-file("src/pearl.gleam", 270).
-spec lex_escape_sequence(lexer()) -> {lexer(), binary()}.
lex_escape_sequence(Lexer) ->
    case erlang:element(2, Lexer) of
        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^a"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^b"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^c"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^d"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^e"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^f"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^g"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^h"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^i"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^j"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^k"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^l"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^m"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^n"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^o"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^p"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^q"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^r"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^s"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^t"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^u"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^v"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^w"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^x"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^y"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^z"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^A"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^B"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^C"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^D"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^E"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^F"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^G"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^H"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^I"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^J"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^K"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^L"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^M"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^N"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^O"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^P"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^Q"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^R"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^S"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^T"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^U"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^V"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^W"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^X"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^Y"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^Z"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^@"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^["/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^\\"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^]"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^^"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^_"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<Sequence:2/binary, Source/binary>> when Sequence =:= <<"^?"/utf8>> ->
            {advance(Lexer, Source), Sequence};

        <<"x{"/utf8, Source@1/binary>> ->
            lex_brace_escape_sequence(advance(Lexer, Source@1));

        <<"x"/utf8, Source@2/binary>> ->
            lex_hex_escape_sequence(advance(Lexer, Source@2));

        <<Char:1/binary, Source@3/binary>> when Char =:= <<"0"/utf8>> ->
            lex_octal_escape_sequence(advance(Lexer, Source@3), Char);

        <<Char:1/binary, Source@3/binary>> when Char =:= <<"1"/utf8>> ->
            lex_octal_escape_sequence(advance(Lexer, Source@3), Char);

        <<Char:1/binary, Source@3/binary>> when Char =:= <<"2"/utf8>> ->
            lex_octal_escape_sequence(advance(Lexer, Source@3), Char);

        <<Char:1/binary, Source@3/binary>> when Char =:= <<"3"/utf8>> ->
            lex_octal_escape_sequence(advance(Lexer, Source@3), Char);

        <<Char:1/binary, Source@3/binary>> when Char =:= <<"4"/utf8>> ->
            lex_octal_escape_sequence(advance(Lexer, Source@3), Char);

        <<Char:1/binary, Source@3/binary>> when Char =:= <<"5"/utf8>> ->
            lex_octal_escape_sequence(advance(Lexer, Source@3), Char);

        <<Char:1/binary, Source@3/binary>> when Char =:= <<"6"/utf8>> ->
            lex_octal_escape_sequence(advance(Lexer, Source@3), Char);

        <<Char:1/binary, Source@3/binary>> when Char =:= <<"7"/utf8>> ->
            lex_octal_escape_sequence(advance(Lexer, Source@3), Char);

        _ ->
            case gleam_stdlib:string_pop_grapheme(erlang:element(2, Lexer)) of
                {error, _} ->
                    {error(Lexer, unterminated_escape_sequence), <<""/utf8>>};

                {ok, {Char@1, Source@4}} ->
                    {advance(Lexer, Source@4), Char@1}
            end
    end.

-file("src/pearl.gleam", 255).
-spec lex_character(lexer()) -> {lexer(), pearl@token:token()}.
lex_character(Lexer) ->
    case erlang:element(2, Lexer) of
        <<"\\"/utf8, Source/binary>> ->
            {Lexer@1, Escape_sequence} = lex_escape_sequence(
                advance(Lexer, Source)
            ),
            {Lexer@1, {character, <<"\\"/utf8, Escape_sequence/binary>>}};

        _ ->
            case gleam_stdlib:string_pop_grapheme(erlang:element(2, Lexer)) of
                {ok, {Char, Source@1}} ->
                    {advance(Lexer, Source@1), {character, Char}};

                {error, _} ->
                    {error(Lexer, unterminated_character),
                        {character, <<""/utf8>>}}
            end
    end.

-file("src/pearl.gleam", 442).
-spec lex_number(lexer(), binary(), lex_number_mode(), delimited_position()) -> {lexer(),
    pearl@token:token()}.
lex_number(Lexer, Lexed, Mode, Position) ->
    Radix = case Mode of
        {radix, R} ->
            R;

        initial ->
            10;

        decimal ->
            10;

        exponent ->
            10
    end,
    case erlang:element(2, Lexer) of
        <<Char:1/binary, Source/binary>> when Char =:= <<"0"/utf8>> ->
            lex_number(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>,
                Mode,
                after_number
            );

        <<Char:1/binary, Source/binary>> when Char =:= <<"1"/utf8>> ->
            lex_number(
                advance(Lexer, Source),
                <<Lexed/binary, Char/binary>>,
                Mode,
                after_number
            );

        <<Char@1:1/binary, Source@1/binary>> when (Char@1 =:= <<"2"/utf8>>) andalso (Radix >= 3) ->
            lex_number(
                advance(Lexer, Source@1),
                <<Lexed/binary, Char@1/binary>>,
                Mode,
                after_number
            );

        <<Char@2:1/binary, Source@2/binary>> when (Char@2 =:= <<"3"/utf8>>) andalso (Radix >= 4) ->
            lex_number(
                advance(Lexer, Source@2),
                <<Lexed/binary, Char@2/binary>>,
                Mode,
                after_number
            );

        <<Char@3:1/binary, Source@3/binary>> when (Char@3 =:= <<"4"/utf8>>) andalso (Radix >= 5) ->
            lex_number(
                advance(Lexer, Source@3),
                <<Lexed/binary, Char@3/binary>>,
                Mode,
                after_number
            );

        <<Char@4:1/binary, Source@4/binary>> when (Char@4 =:= <<"5"/utf8>>) andalso (Radix >= 6) ->
            lex_number(
                advance(Lexer, Source@4),
                <<Lexed/binary, Char@4/binary>>,
                Mode,
                after_number
            );

        <<Char@5:1/binary, Source@5/binary>> when (Char@5 =:= <<"6"/utf8>>) andalso (Radix >= 7) ->
            lex_number(
                advance(Lexer, Source@5),
                <<Lexed/binary, Char@5/binary>>,
                Mode,
                after_number
            );

        <<Char@6:1/binary, Source@6/binary>> when (Char@6 =:= <<"7"/utf8>>) andalso (Radix >= 8) ->
            lex_number(
                advance(Lexer, Source@6),
                <<Lexed/binary, Char@6/binary>>,
                Mode,
                after_number
            );

        <<Char@7:1/binary, Source@7/binary>> when (Char@7 =:= <<"8"/utf8>>) andalso (Radix >= 9) ->
            lex_number(
                advance(Lexer, Source@7),
                <<Lexed/binary, Char@7/binary>>,
                Mode,
                after_number
            );

        <<Char@8:1/binary, Source@8/binary>> when (Char@8 =:= <<"9"/utf8>>) andalso (Radix >= 10) ->
            lex_number(
                advance(Lexer, Source@8),
                <<Lexed/binary, Char@8/binary>>,
                Mode,
                after_number
            );

        <<Char@9:1/binary, Source@9/binary>> when (Char@9 =:= <<"a"/utf8>>) andalso (Radix >= 11) ->
            lex_number(
                advance(Lexer, Source@9),
                <<Lexed/binary, Char@9/binary>>,
                Mode,
                after_number
            );

        <<Char@9:1/binary, Source@9/binary>> when (Char@9 =:= <<"A"/utf8>>) andalso (Radix >= 11) ->
            lex_number(
                advance(Lexer, Source@9),
                <<Lexed/binary, Char@9/binary>>,
                Mode,
                after_number
            );

        <<Char@10:1/binary, Source@10/binary>> when (Char@10 =:= <<"b"/utf8>>) andalso (Radix >= 12) ->
            lex_number(
                advance(Lexer, Source@10),
                <<Lexed/binary, Char@10/binary>>,
                Mode,
                after_number
            );

        <<Char@10:1/binary, Source@10/binary>> when (Char@10 =:= <<"B"/utf8>>) andalso (Radix >= 12) ->
            lex_number(
                advance(Lexer, Source@10),
                <<Lexed/binary, Char@10/binary>>,
                Mode,
                after_number
            );

        <<Char@11:1/binary, Source@11/binary>> when (Char@11 =:= <<"c"/utf8>>) andalso (Radix >= 13) ->
            lex_number(
                advance(Lexer, Source@11),
                <<Lexed/binary, Char@11/binary>>,
                Mode,
                after_number
            );

        <<Char@11:1/binary, Source@11/binary>> when (Char@11 =:= <<"C"/utf8>>) andalso (Radix >= 13) ->
            lex_number(
                advance(Lexer, Source@11),
                <<Lexed/binary, Char@11/binary>>,
                Mode,
                after_number
            );

        <<Char@12:1/binary, Source@12/binary>> when (Char@12 =:= <<"d"/utf8>>) andalso (Radix >= 14) ->
            lex_number(
                advance(Lexer, Source@12),
                <<Lexed/binary, Char@12/binary>>,
                Mode,
                after_number
            );

        <<Char@12:1/binary, Source@12/binary>> when (Char@12 =:= <<"D"/utf8>>) andalso (Radix >= 14) ->
            lex_number(
                advance(Lexer, Source@12),
                <<Lexed/binary, Char@12/binary>>,
                Mode,
                after_number
            );

        <<Char@13:1/binary, Source@13/binary>> when (Char@13 =:= <<"e"/utf8>>) andalso (Radix >= 15) ->
            lex_number(
                advance(Lexer, Source@13),
                <<Lexed/binary, Char@13/binary>>,
                Mode,
                after_number
            );

        <<Char@13:1/binary, Source@13/binary>> when (Char@13 =:= <<"E"/utf8>>) andalso (Radix >= 15) ->
            lex_number(
                advance(Lexer, Source@13),
                <<Lexed/binary, Char@13/binary>>,
                Mode,
                after_number
            );

        <<Char@14:1/binary, Source@14/binary>> when (Char@14 =:= <<"f"/utf8>>) andalso (Radix >= 16) ->
            lex_number(
                advance(Lexer, Source@14),
                <<Lexed/binary, Char@14/binary>>,
                Mode,
                after_number
            );

        <<Char@14:1/binary, Source@14/binary>> when (Char@14 =:= <<"F"/utf8>>) andalso (Radix >= 16) ->
            lex_number(
                advance(Lexer, Source@14),
                <<Lexed/binary, Char@14/binary>>,
                Mode,
                after_number
            );

        <<Char@15:1/binary, Source@15/binary>> when (Char@15 =:= <<"g"/utf8>>) andalso (Radix >= 17) ->
            lex_number(
                advance(Lexer, Source@15),
                <<Lexed/binary, Char@15/binary>>,
                Mode,
                after_number
            );

        <<Char@15:1/binary, Source@15/binary>> when (Char@15 =:= <<"G"/utf8>>) andalso (Radix >= 17) ->
            lex_number(
                advance(Lexer, Source@15),
                <<Lexed/binary, Char@15/binary>>,
                Mode,
                after_number
            );

        <<Char@16:1/binary, Source@16/binary>> when (Char@16 =:= <<"h"/utf8>>) andalso (Radix >= 18) ->
            lex_number(
                advance(Lexer, Source@16),
                <<Lexed/binary, Char@16/binary>>,
                Mode,
                after_number
            );

        <<Char@16:1/binary, Source@16/binary>> when (Char@16 =:= <<"H"/utf8>>) andalso (Radix >= 18) ->
            lex_number(
                advance(Lexer, Source@16),
                <<Lexed/binary, Char@16/binary>>,
                Mode,
                after_number
            );

        <<Char@17:1/binary, Source@17/binary>> when (Char@17 =:= <<"i"/utf8>>) andalso (Radix >= 19) ->
            lex_number(
                advance(Lexer, Source@17),
                <<Lexed/binary, Char@17/binary>>,
                Mode,
                after_number
            );

        <<Char@17:1/binary, Source@17/binary>> when (Char@17 =:= <<"I"/utf8>>) andalso (Radix >= 19) ->
            lex_number(
                advance(Lexer, Source@17),
                <<Lexed/binary, Char@17/binary>>,
                Mode,
                after_number
            );

        <<Char@18:1/binary, Source@18/binary>> when (Char@18 =:= <<"j"/utf8>>) andalso (Radix >= 20) ->
            lex_number(
                advance(Lexer, Source@18),
                <<Lexed/binary, Char@18/binary>>,
                Mode,
                after_number
            );

        <<Char@18:1/binary, Source@18/binary>> when (Char@18 =:= <<"J"/utf8>>) andalso (Radix >= 20) ->
            lex_number(
                advance(Lexer, Source@18),
                <<Lexed/binary, Char@18/binary>>,
                Mode,
                after_number
            );

        <<Char@19:1/binary, Source@19/binary>> when (Char@19 =:= <<"k"/utf8>>) andalso (Radix >= 21) ->
            lex_number(
                advance(Lexer, Source@19),
                <<Lexed/binary, Char@19/binary>>,
                Mode,
                after_number
            );

        <<Char@19:1/binary, Source@19/binary>> when (Char@19 =:= <<"K"/utf8>>) andalso (Radix >= 21) ->
            lex_number(
                advance(Lexer, Source@19),
                <<Lexed/binary, Char@19/binary>>,
                Mode,
                after_number
            );

        <<Char@20:1/binary, Source@20/binary>> when (Char@20 =:= <<"l"/utf8>>) andalso (Radix >= 22) ->
            lex_number(
                advance(Lexer, Source@20),
                <<Lexed/binary, Char@20/binary>>,
                Mode,
                after_number
            );

        <<Char@20:1/binary, Source@20/binary>> when (Char@20 =:= <<"L"/utf8>>) andalso (Radix >= 22) ->
            lex_number(
                advance(Lexer, Source@20),
                <<Lexed/binary, Char@20/binary>>,
                Mode,
                after_number
            );

        <<Char@21:1/binary, Source@21/binary>> when (Char@21 =:= <<"m"/utf8>>) andalso (Radix >= 23) ->
            lex_number(
                advance(Lexer, Source@21),
                <<Lexed/binary, Char@21/binary>>,
                Mode,
                after_number
            );

        <<Char@21:1/binary, Source@21/binary>> when (Char@21 =:= <<"M"/utf8>>) andalso (Radix >= 23) ->
            lex_number(
                advance(Lexer, Source@21),
                <<Lexed/binary, Char@21/binary>>,
                Mode,
                after_number
            );

        <<Char@22:1/binary, Source@22/binary>> when (Char@22 =:= <<"n"/utf8>>) andalso (Radix >= 24) ->
            lex_number(
                advance(Lexer, Source@22),
                <<Lexed/binary, Char@22/binary>>,
                Mode,
                after_number
            );

        <<Char@22:1/binary, Source@22/binary>> when (Char@22 =:= <<"N"/utf8>>) andalso (Radix >= 24) ->
            lex_number(
                advance(Lexer, Source@22),
                <<Lexed/binary, Char@22/binary>>,
                Mode,
                after_number
            );

        <<Char@23:1/binary, Source@23/binary>> when (Char@23 =:= <<"o"/utf8>>) andalso (Radix >= 25) ->
            lex_number(
                advance(Lexer, Source@23),
                <<Lexed/binary, Char@23/binary>>,
                Mode,
                after_number
            );

        <<Char@23:1/binary, Source@23/binary>> when (Char@23 =:= <<"O"/utf8>>) andalso (Radix >= 25) ->
            lex_number(
                advance(Lexer, Source@23),
                <<Lexed/binary, Char@23/binary>>,
                Mode,
                after_number
            );

        <<Char@24:1/binary, Source@24/binary>> when (Char@24 =:= <<"p"/utf8>>) andalso (Radix >= 26) ->
            lex_number(
                advance(Lexer, Source@24),
                <<Lexed/binary, Char@24/binary>>,
                Mode,
                after_number
            );

        <<Char@24:1/binary, Source@24/binary>> when (Char@24 =:= <<"P"/utf8>>) andalso (Radix >= 26) ->
            lex_number(
                advance(Lexer, Source@24),
                <<Lexed/binary, Char@24/binary>>,
                Mode,
                after_number
            );

        <<Char@25:1/binary, Source@25/binary>> when (Char@25 =:= <<"q"/utf8>>) andalso (Radix >= 27) ->
            lex_number(
                advance(Lexer, Source@25),
                <<Lexed/binary, Char@25/binary>>,
                Mode,
                after_number
            );

        <<Char@25:1/binary, Source@25/binary>> when (Char@25 =:= <<"Q"/utf8>>) andalso (Radix >= 27) ->
            lex_number(
                advance(Lexer, Source@25),
                <<Lexed/binary, Char@25/binary>>,
                Mode,
                after_number
            );

        <<Char@26:1/binary, Source@26/binary>> when (Char@26 =:= <<"r"/utf8>>) andalso (Radix >= 28) ->
            lex_number(
                advance(Lexer, Source@26),
                <<Lexed/binary, Char@26/binary>>,
                Mode,
                after_number
            );

        <<Char@26:1/binary, Source@26/binary>> when (Char@26 =:= <<"R"/utf8>>) andalso (Radix >= 28) ->
            lex_number(
                advance(Lexer, Source@26),
                <<Lexed/binary, Char@26/binary>>,
                Mode,
                after_number
            );

        <<Char@27:1/binary, Source@27/binary>> when (Char@27 =:= <<"s"/utf8>>) andalso (Radix >= 29) ->
            lex_number(
                advance(Lexer, Source@27),
                <<Lexed/binary, Char@27/binary>>,
                Mode,
                after_number
            );

        <<Char@27:1/binary, Source@27/binary>> when (Char@27 =:= <<"S"/utf8>>) andalso (Radix >= 29) ->
            lex_number(
                advance(Lexer, Source@27),
                <<Lexed/binary, Char@27/binary>>,
                Mode,
                after_number
            );

        <<Char@28:1/binary, Source@28/binary>> when (Char@28 =:= <<"t"/utf8>>) andalso (Radix >= 30) ->
            lex_number(
                advance(Lexer, Source@28),
                <<Lexed/binary, Char@28/binary>>,
                Mode,
                after_number
            );

        <<Char@28:1/binary, Source@28/binary>> when (Char@28 =:= <<"T"/utf8>>) andalso (Radix >= 30) ->
            lex_number(
                advance(Lexer, Source@28),
                <<Lexed/binary, Char@28/binary>>,
                Mode,
                after_number
            );

        <<Char@29:1/binary, Source@29/binary>> when (Char@29 =:= <<"u"/utf8>>) andalso (Radix >= 31) ->
            lex_number(
                advance(Lexer, Source@29),
                <<Lexed/binary, Char@29/binary>>,
                Mode,
                after_number
            );

        <<Char@29:1/binary, Source@29/binary>> when (Char@29 =:= <<"U"/utf8>>) andalso (Radix >= 31) ->
            lex_number(
                advance(Lexer, Source@29),
                <<Lexed/binary, Char@29/binary>>,
                Mode,
                after_number
            );

        <<Char@30:1/binary, Source@30/binary>> when (Char@30 =:= <<"v"/utf8>>) andalso (Radix >= 32) ->
            lex_number(
                advance(Lexer, Source@30),
                <<Lexed/binary, Char@30/binary>>,
                Mode,
                after_number
            );

        <<Char@30:1/binary, Source@30/binary>> when (Char@30 =:= <<"V"/utf8>>) andalso (Radix >= 32) ->
            lex_number(
                advance(Lexer, Source@30),
                <<Lexed/binary, Char@30/binary>>,
                Mode,
                after_number
            );

        <<Char@31:1/binary, Source@31/binary>> when (Char@31 =:= <<"w"/utf8>>) andalso (Radix >= 33) ->
            lex_number(
                advance(Lexer, Source@31),
                <<Lexed/binary, Char@31/binary>>,
                Mode,
                after_number
            );

        <<Char@31:1/binary, Source@31/binary>> when (Char@31 =:= <<"W"/utf8>>) andalso (Radix >= 33) ->
            lex_number(
                advance(Lexer, Source@31),
                <<Lexed/binary, Char@31/binary>>,
                Mode,
                after_number
            );

        <<Char@32:1/binary, Source@32/binary>> when (Char@32 =:= <<"x"/utf8>>) andalso (Radix >= 34) ->
            lex_number(
                advance(Lexer, Source@32),
                <<Lexed/binary, Char@32/binary>>,
                Mode,
                after_number
            );

        <<Char@32:1/binary, Source@32/binary>> when (Char@32 =:= <<"X"/utf8>>) andalso (Radix >= 34) ->
            lex_number(
                advance(Lexer, Source@32),
                <<Lexed/binary, Char@32/binary>>,
                Mode,
                after_number
            );

        <<Char@33:1/binary, Source@33/binary>> when (Char@33 =:= <<"y"/utf8>>) andalso (Radix >= 35) ->
            lex_number(
                advance(Lexer, Source@33),
                <<Lexed/binary, Char@33/binary>>,
                Mode,
                after_number
            );

        <<Char@33:1/binary, Source@33/binary>> when (Char@33 =:= <<"Y"/utf8>>) andalso (Radix >= 35) ->
            lex_number(
                advance(Lexer, Source@33),
                <<Lexed/binary, Char@33/binary>>,
                Mode,
                after_number
            );

        <<Char@34:1/binary, Source@34/binary>> when (Char@34 =:= <<"z"/utf8>>) andalso (Radix >= 36) ->
            lex_number(
                advance(Lexer, Source@34),
                <<Lexed/binary, Char@34/binary>>,
                Mode,
                after_number
            );

        <<Char@34:1/binary, Source@34/binary>> when (Char@34 =:= <<"Z"/utf8>>) andalso (Radix >= 36) ->
            lex_number(
                advance(Lexer, Source@34),
                <<Lexed/binary, Char@34/binary>>,
                Mode,
                after_number
            );

        <<"#"/utf8, Source@35/binary>> when (Mode =:= initial) andalso (Position =:= after_number) ->
            case gleam_stdlib:parse_int(
                gleam@string:replace(Lexed, <<"_"/utf8>>, <<""/utf8>>)
            ) of
                {error, _} ->
                    {error(advance(Lexer, Source@35), {invalid_radix, Lexed}),
                        {integer, Lexed}};

                {ok, Radix@1} when (Radix@1 < 2) orelse (Radix@1 > 36) ->
                    {error(advance(Lexer, Source@35), {invalid_radix, Lexed}),
                        {integer, Lexed}};

                {ok, Radix@2} ->
                    lex_number(
                        advance(Lexer, Source@35),
                        <<Lexed/binary, "#"/utf8>>,
                        {radix, Radix@2},
                        after_radix
                    )
            end;

        <<"_"/utf8, Source@36/binary>> when Position =:= after_number ->
            lex_number(
                advance(Lexer, Source@36),
                <<Lexed/binary, "_"/utf8>>,
                Mode,
                after_separator
            );

        <<"_"/utf8, _/binary>> ->
            {error(Lexer, numeric_separator_not_allowed), {integer, Lexed}};

        <<"."/utf8, Source@37/binary>> when (Mode =:= initial) andalso (Position =:= after_number) ->
            lex_number(
                advance(Lexer, Source@37),
                <<Lexed/binary, "."/utf8>>,
                decimal,
                after_decimal
            );

        <<Prefix:2/binary, Source@38/binary>> when (Prefix =:= <<"e-"/utf8>>) andalso ((Mode =:= decimal) andalso (Position =:= after_number)) ->
            lex_number(
                advance(Lexer, Source@38),
                <<Lexed/binary, Prefix/binary>>,
                exponent,
                after_exponent
            );

        <<Prefix:1/binary, Source@38/binary>> when (Prefix =:= <<"e"/utf8>>) andalso ((Mode =:= decimal) andalso (Position =:= after_number)) ->
            lex_number(
                advance(Lexer, Source@38),
                <<Lexed/binary, Prefix/binary>>,
                exponent,
                after_exponent
            );

        <<Prefix:2/binary, Source@38/binary>> when (Prefix =:= <<"E-"/utf8>>) andalso ((Mode =:= decimal) andalso (Position =:= after_number)) ->
            lex_number(
                advance(Lexer, Source@38),
                <<Lexed/binary, Prefix/binary>>,
                exponent,
                after_exponent
            );

        <<Prefix:1/binary, Source@38/binary>> when (Prefix =:= <<"E"/utf8>>) andalso ((Mode =:= decimal) andalso (Position =:= after_number)) ->
            lex_number(
                advance(Lexer, Source@38),
                <<Lexed/binary, Prefix/binary>>,
                exponent,
                after_exponent
            );

        _ ->
            Token = case Mode of
                decimal ->
                    {float, Lexed};

                exponent ->
                    {float, Lexed};

                initial ->
                    {integer, Lexed};

                {radix, _} ->
                    {integer, Lexed}
            end,
            case Position of
                after_decimal ->
                    {advance(
                            Lexer,
                            <<"."/utf8, (erlang:element(2, Lexer))/binary>>
                        ),
                        {integer, gleam@string:drop_end(Lexed, 1)}};

                after_exponent ->
                    {error(Lexer, expected_exponent), Token};

                after_radix ->
                    {error(Lexer, number_cannot_end_after_radix), Token};

                after_number ->
                    {Lexer, Token};

                after_separator ->
                    {error(Lexer, numeric_separator_not_allowed), Token}
            end
    end.

-file("src/pearl.gleam", 647).
-spec do_lex_sigil(
    lexer(),
    binary(),
    pearl@token:sigil_delimiter(),
    binary(),
    splitter:splitter(),
    binary()
) -> {lexer(), pearl@token:token()}.
do_lex_sigil(Lexer, Sigil, Delimiter, Closing_char, Splitter, Contents) ->
    {Before, Split, After} = splitter_ffi:split(
        Splitter,
        erlang:element(2, Lexer)
    ),
    case Split of
        <<""/utf8>> ->
            {error(advance(Lexer, After), unterminated_string),
                {unterminated_sigil,
                    Sigil,
                    Delimiter,
                    <<Contents/binary, Before/binary>>}};

        <<"\\"/utf8>> ->
            case gleam_stdlib:string_pop_grapheme(After) of
                {error, _} ->
                    {error(advance(Lexer, After), unterminated_string),
                        {unterminated_sigil,
                            Sigil,
                            Delimiter,
                            <<<<Contents/binary, Before/binary>>/binary,
                                "\\"/utf8>>}};

                {ok, {Character, Source}} ->
                    do_lex_sigil(
                        advance(Lexer, Source),
                        Sigil,
                        Delimiter,
                        Closing_char,
                        Splitter,
                        <<<<<<Contents/binary, Before/binary>>/binary,
                                "\\"/utf8>>/binary,
                            Character/binary>>
                    )
            end;

        _ when Split =:= Closing_char ->
            {advance(Lexer, After),
                {sigil, Sigil, Delimiter, <<Contents/binary, Before/binary>>}};

        _ ->
            do_lex_sigil(
                advance(Lexer, After),
                Sigil,
                Delimiter,
                Closing_char,
                Splitter,
                <<<<Contents/binary, Before/binary>>/binary, Split/binary>>
            )
    end.

-file("src/pearl.gleam", 703).
-spec lex_string(lexer(), binary()) -> {lexer(), pearl@token:token()}.
lex_string(Lexer, Contents) ->
    {Before, Split, After} = splitter_ffi:split(
        erlang:element(3, erlang:element(6, Lexer)),
        erlang:element(2, Lexer)
    ),
    case Split of
        <<""/utf8>> ->
            {error(advance(Lexer, After), unterminated_string),
                {unterminated_string, <<Contents/binary, Before/binary>>}};

        <<"\\"/utf8>> ->
            {Lexer@1, Escape} = lex_escape_sequence(advance(Lexer, After)),
            lex_string(
                Lexer@1,
                <<<<<<Contents/binary, Before/binary>>/binary, "\\"/utf8>>/binary,
                    Escape/binary>>
            );

        _ ->
            {advance(Lexer, After),
                {string, <<Contents/binary, Before/binary>>}}
    end.

-file("src/pearl.gleam", 810).
-spec lex_triple_quoted_string_contents(
    lexer(),
    list(binary()),
    binary(),
    integer()
) -> {lexer(), list(binary()), binary()}.
lex_triple_quoted_string_contents(Lexer, Lines, Current_line, Extra_quotes) ->
    {Before, Split, After} = splitter_ffi:split(
        erlang:element(8, erlang:element(6, Lexer)),
        erlang:element(2, Lexer)
    ),
    Before@1 = <<Current_line/binary, Before/binary>>,
    case Split of
        <<"\"\"\""/utf8>> ->
            Lexer@1 = advance(Lexer, After),
            case is_whitespace(Before@1) of
                false ->
                    lex_triple_quoted_string_contents(
                        Lexer@1,
                        Lines,
                        <<Before@1/binary, "\"\"\""/utf8>>,
                        Extra_quotes
                    );

                true when Extra_quotes =:= 0 ->
                    {Lexer@1, Lines, Before@1};

                true ->
                    case consume_extra_quotes(Lexer@1, Extra_quotes) of
                        {ok, Lexer@2} ->
                            {Lexer@2, Lines, Before@1};

                        {error, nil} ->
                            lex_triple_quoted_string_contents(
                                Lexer@1,
                                Lines,
                                <<Before@1/binary, "\"\"\""/utf8>>,
                                Extra_quotes
                            )
                    end
            end;

        <<"\n"/utf8>> ->
            lex_triple_quoted_string_contents(
                advance(Lexer, After),
                [Before@1 | Lines],
                <<""/utf8>>,
                Extra_quotes
            );

        <<"\r\n"/utf8>> ->
            lex_triple_quoted_string_contents(
                advance(Lexer, After),
                [Before@1 | Lines],
                <<""/utf8>>,
                Extra_quotes
            );

        _ ->
            {error(Lexer, unterminated_string), [Before@1 | Lines], <<""/utf8>>}
    end.

-file("src/pearl.gleam", 721).
-spec lex_triple_quoted_string(lexer(), gleam@option:option(binary())) -> {lexer(),
    pearl@token:token()}.
lex_triple_quoted_string(Lexer, Sigil) ->
    {Lexer@1, Extra_quotes} = count_extra_quotes(Lexer, 0),
    {Lexer@2, Beginning_whitespace} = case splitter_ffi:split(
        erlang:element(2, erlang:element(6, Lexer@1)),
        erlang:element(2, Lexer@1)
    ) of
        {_, <<""/utf8>>, _} ->
            {error(Lexer@1, expected_whitespace_after_triple_quote),
                <<""/utf8>>};

        {Before, Newline, After} ->
            case is_whitespace(Before) of
                true ->
                    {advance(Lexer@1, After), <<Before/binary, Newline/binary>>};

                false ->
                    {error(Lexer@1, expected_whitespace_after_triple_quote),
                        <<""/utf8>>}
            end
    end,
    {Lexer@3, Lines, End_indentation} = lex_triple_quoted_string_contents(
        Lexer@2,
        [],
        <<""/utf8>>,
        Extra_quotes
    ),
    case strip_line_prefixes(Lines, End_indentation, []) of
        {error, Line} ->
            Contents = <<<<<<Beginning_whitespace/binary,
                        (gleam@string:join(lists:reverse(Lines), <<"\n"/utf8>>))/binary>>/binary,
                    "\n"/utf8>>/binary,
                End_indentation/binary>>,
            {error(
                    Lexer@3,
                    {invalid_triple_quoted_string_indentation,
                        End_indentation,
                        Line}
                ),
                {invalid_triple_quoted_string, Contents}};

        {ok, Lines@1} ->
            {Lexer@3,
                {triple_quoted_string,
                    Sigil,
                    Extra_quotes + 3,
                    Beginning_whitespace,
                    Lines@1,
                    End_indentation}}
    end.

-file("src/pearl.gleam", 589).
-spec lex_sigil(lexer()) -> {lexer(), pearl@token:token()}.
lex_sigil(Lexer) ->
    {Lexer@1, Sigil@2, Verbatim} = case erlang:element(2, Lexer) of
        <<Sigil:1/binary, Source/binary>> when Sigil =:= <<"b"/utf8>> ->
            {advance(Lexer, Source), Sigil, false};

        <<Sigil:1/binary, Source/binary>> when Sigil =:= <<"s"/utf8>> ->
            {advance(Lexer, Source), Sigil, false};

        <<Sigil@1:1/binary, Source@1/binary>> when Sigil@1 =:= <<"B"/utf8>> ->
            {advance(Lexer, Source@1), Sigil@1, true};

        <<Sigil@1:1/binary, Source@1/binary>> when Sigil@1 =:= <<"S"/utf8>> ->
            {advance(Lexer, Source@1), Sigil@1, true};

        _ ->
            {Lexer, <<""/utf8>>, false}
    end,
    case erlang:element(2, Lexer@1) of
        <<"\"\"\""/utf8, Source@2/binary>> ->
            lex_triple_quoted_string(
                advance(Lexer@1, Source@2),
                {some, Sigil@2}
            );

        _ ->
            {Lexer@2, Delimiter, Closing_char} = case erlang:element(2, Lexer@1) of
                <<"("/utf8, Source@3/binary>> ->
                    {advance(Lexer@1, Source@3), sigil_paren, <<")"/utf8>>};

                <<"["/utf8, Source@4/binary>> ->
                    {advance(Lexer@1, Source@4), sigil_square, <<"]"/utf8>>};

                <<"{"/utf8, Source@5/binary>> ->
                    {advance(Lexer@1, Source@5), sigil_brace, <<"}"/utf8>>};

                <<"<"/utf8, Source@6/binary>> ->
                    {advance(Lexer@1, Source@6), sigil_angle, <<">"/utf8>>};

                <<"/"/utf8, Source@7/binary>> ->
                    {advance(Lexer@1, Source@7), sigil_slash, <<"/"/utf8>>};

                <<"|"/utf8, Source@8/binary>> ->
                    {advance(Lexer@1, Source@8), sigil_pipe, <<"|"/utf8>>};

                <<"'"/utf8, Source@9/binary>> ->
                    {advance(Lexer@1, Source@9),
                        sigil_single_quote,
                        <<"'"/utf8>>};

                <<"\""/utf8, Source@10/binary>> ->
                    {advance(Lexer@1, Source@10),
                        sigil_double_quote,
                        <<"\""/utf8>>};

                <<"`"/utf8, Source@11/binary>> ->
                    {advance(Lexer@1, Source@11), sigil_backtick, <<"`"/utf8>>};

                <<"#"/utf8, Source@12/binary>> ->
                    {advance(Lexer@1, Source@12), sigil_hash, <<"#"/utf8>>};

                _ ->
                    {error(Lexer@1, expected_sigil_delimiter),
                        sigil_none,
                        <<""/utf8>>}
            end,
            case Delimiter of
                sigil_none ->
                    {Lexer@2,
                        {unterminated_sigil, Sigil@2, Delimiter, <<""/utf8>>}};

                _ ->
                    Splitter = case Verbatim of
                        false ->
                            erlang:element(6, erlang:element(6, Lexer@2));

                        true ->
                            erlang:element(7, erlang:element(6, Lexer@2))
                    end,
                    do_lex_sigil(
                        Lexer@2,
                        Sigil@2,
                        Delimiter,
                        Closing_char,
                        Splitter,
                        <<""/utf8>>
                    )
            end
    end.

-file("src/pearl.gleam", 868).
-spec lex_quoted_atom(lexer(), binary()) -> {lexer(), pearl@token:token()}.
lex_quoted_atom(Lexer, Contents) ->
    {Before, Split, After} = splitter_ffi:split(
        erlang:element(4, erlang:element(6, Lexer)),
        erlang:element(2, Lexer)
    ),
    case Split of
        <<""/utf8>> ->
            {error(advance(Lexer, After), unterminated_atom),
                {unterminated_atom, <<Contents/binary, Before/binary>>}};

        <<"\\"/utf8>> ->
            case gleam_stdlib:string_pop_grapheme(After) of
                {error, _} ->
                    {error(advance(Lexer, After), unterminated_string),
                        {unterminated_string, Contents}};

                {ok, {Character, Source}} ->
                    lex_string(
                        advance(Lexer, Source),
                        <<<<<<Contents/binary, Before/binary>>/binary,
                                "\\"/utf8>>/binary,
                            Character/binary>>
                    )
            end;

        _ ->
            {advance(Lexer, After),
                {atom, <<Contents/binary, Before/binary>>, true}}
    end.

-file("src/pearl.gleam", 1028).
-spec maybe_token(lexer(), pearl@token:token(), boolean()) -> {lexer(),
    pearl@token:token()}.
maybe_token(Lexer, Token, Condition) ->
    case Condition of
        true ->
            {Lexer, Token};

        false ->
            next(Lexer)
    end.

-file("src/pearl.gleam", 100).
-spec next(lexer()) -> {lexer(), pearl@token:token()}.
next(Lexer) ->
    case erlang:element(2, Lexer) of
        <<""/utf8>> ->
            {Lexer, end_of_file};

        <<Space:1/binary, Source/binary>> when Space =:= <<" "/utf8>> ->
            lex_whitespace(advance(Lexer, Source), Space);

        <<Space:1/binary, Source/binary>> when Space =:= <<"\n"/utf8>> ->
            lex_whitespace(advance(Lexer, Source), Space);

        <<Space:1/binary, Source/binary>> when Space =:= <<"\r"/utf8>> ->
            lex_whitespace(advance(Lexer, Source), Space);

        <<Space:1/binary, Source/binary>> when Space =:= <<"\t"/utf8>> ->
            lex_whitespace(advance(Lexer, Source), Space);

        <<Space:1/binary, Source/binary>> when Space =:= <<"\f"/utf8>> ->
            lex_whitespace(advance(Lexer, Source), Space);

        <<"%%%"/utf8, Source@1/binary>> ->
            {Lexer@1, Contents} = lex_until_end_of_line(
                advance(Lexer, Source@1)
            ),
            maybe_token(
                Lexer@1,
                {module_comment, Contents},
                not erlang:element(3, Lexer@1)
            );

        <<"%%"/utf8, Source@2/binary>> ->
            {Lexer@2, Contents@1} = lex_until_end_of_line(
                advance(Lexer, Source@2)
            ),
            maybe_token(
                Lexer@2,
                {doc_comment, Contents@1},
                not erlang:element(3, Lexer@2)
            );

        <<"%"/utf8, Source@3/binary>> ->
            {Lexer@3, Contents@2} = lex_until_end_of_line(
                advance(Lexer, Source@3)
            ),
            maybe_token(
                Lexer@3,
                {comment, Contents@2},
                not erlang:element(3, Lexer@3)
            );

        <<"::"/utf8, Source@4/binary>> ->
            {advance(Lexer, Source@4), double_colon};

        <<":="/utf8, Source@5/binary>> ->
            {advance(Lexer, Source@5), colon_equal};

        <<":"/utf8, Source@6/binary>> ->
            {advance(Lexer, Source@6), colon};

        <<"..."/utf8, Source@7/binary>> ->
            {advance(Lexer, Source@7), triple_dot};

        <<".."/utf8, Source@8/binary>> ->
            {advance(Lexer, Source@8), double_dot};

        <<"("/utf8, Source@9/binary>> ->
            {advance(Lexer, Source@9), left_paren};

        <<")"/utf8, Source@10/binary>> ->
            {advance(Lexer, Source@10), right_paren};

        <<"{"/utf8, Source@11/binary>> ->
            {advance(Lexer, Source@11), left_brace};

        <<"}"/utf8, Source@12/binary>> ->
            {advance(Lexer, Source@12), right_brace};

        <<"["/utf8, Source@13/binary>> ->
            {advance(Lexer, Source@13), left_square};

        <<"]"/utf8, Source@14/binary>> ->
            {advance(Lexer, Source@14), right_square};

        <<","/utf8, Source@15/binary>> ->
            {advance(Lexer, Source@15), comma};

        <<";"/utf8, Source@16/binary>> ->
            {advance(Lexer, Source@16), semicolon};

        <<"."/utf8, Source@17/binary>> ->
            {advance(Lexer, Source@17), dot};

        <<"->"/utf8, Source@18/binary>> ->
            {advance(Lexer, Source@18), minus_greater};

        <<"<<"/utf8, Source@19/binary>> ->
            {advance(Lexer, Source@19), double_less};

        <<">>"/utf8, Source@20/binary>> ->
            {advance(Lexer, Source@20), double_greater};

        <<"#"/utf8, Source@21/binary>> ->
            {advance(Lexer, Source@21), hash};

        <<"||"/utf8, Source@22/binary>> ->
            {advance(Lexer, Source@22), double_pipe};

        <<"=>"/utf8, Source@23/binary>> ->
            {advance(Lexer, Source@23), equal_greater};

        <<"<-"/utf8, Source@24/binary>> ->
            {advance(Lexer, Source@24), less_minus};

        <<"<="/utf8, Source@25/binary>> ->
            {advance(Lexer, Source@25), less_equal};

        <<"|"/utf8, Source@26/binary>> ->
            {advance(Lexer, Source@26), pipe};

        <<"++"/utf8, Source@27/binary>> ->
            {advance(Lexer, Source@27), double_plus};

        <<"--"/utf8, Source@28/binary>> ->
            {advance(Lexer, Source@28), double_minus};

        <<"=="/utf8, Source@29/binary>> ->
            {advance(Lexer, Source@29), double_equal};

        <<"/="/utf8, Source@30/binary>> ->
            {advance(Lexer, Source@30), slash_equal};

        <<"=<"/utf8, Source@31/binary>> ->
            {advance(Lexer, Source@31), equal_less};

        <<"<"/utf8, Source@32/binary>> ->
            {advance(Lexer, Source@32), less};

        <<">="/utf8, Source@33/binary>> ->
            {advance(Lexer, Source@33), greater_equal};

        <<">"/utf8, Source@34/binary>> ->
            {advance(Lexer, Source@34), greater};

        <<"=:="/utf8, Source@35/binary>> ->
            {advance(Lexer, Source@35), equal_colon_equal};

        <<"=/="/utf8, Source@36/binary>> ->
            {advance(Lexer, Source@36), equal_slash_equal};

        <<"+"/utf8, Source@37/binary>> ->
            {advance(Lexer, Source@37), plus};

        <<"-"/utf8, Source@38/binary>> ->
            {advance(Lexer, Source@38), minus};

        <<"*"/utf8, Source@39/binary>> ->
            {advance(Lexer, Source@39), star};

        <<"/"/utf8, Source@40/binary>> ->
            {advance(Lexer, Source@40), slash};

        <<"?="/utf8, Source@41/binary>> ->
            {advance(Lexer, Source@41), question_equal};

        <<"?"/utf8, Source@42/binary>> ->
            {advance(Lexer, Source@42), question};

        <<"!"/utf8, Source@43/binary>> ->
            {advance(Lexer, Source@43), bang};

        <<"="/utf8, Source@44/binary>> ->
            {advance(Lexer, Source@44), equal};

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"a"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"b"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"c"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"d"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"e"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"f"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"g"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"h"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"i"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"j"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"k"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"l"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"m"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"n"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"o"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"p"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"q"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"r"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"s"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"t"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"u"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"v"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"w"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"x"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"y"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char:1/binary, Source@45/binary>> when Char =:= <<"z"/utf8>> ->
            lex_atom(advance(Lexer, Source@45), Char);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"A"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"B"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"C"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"D"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"E"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"F"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"G"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"H"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"I"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"J"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"K"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"L"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"M"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"N"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"O"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"P"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"Q"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"R"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"S"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"T"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"U"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"V"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"W"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"X"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"Y"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"Z"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@1:1/binary, Source@46/binary>> when Char@1 =:= <<"_"/utf8>> ->
            lex_variable(advance(Lexer, Source@46), Char@1);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"0"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"1"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"2"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"3"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"4"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"5"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"6"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"7"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"8"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<Char@2:1/binary, Source@47/binary>> when Char@2 =:= <<"9"/utf8>> ->
            lex_number(advance(Lexer, Source@47), Char@2, initial, after_number);

        <<"\"\"\""/utf8, Source@48/binary>> ->
            lex_triple_quoted_string(advance(Lexer, Source@48), none);

        <<"\""/utf8, Source@49/binary>> ->
            lex_string(advance(Lexer, Source@49), <<""/utf8>>);

        <<"'"/utf8, Source@50/binary>> ->
            lex_quoted_atom(advance(Lexer, Source@50), <<""/utf8>>);

        <<"$"/utf8, Source@51/binary>> ->
            lex_character(advance(Lexer, Source@51));

        <<"~"/utf8, Source@52/binary>> ->
            lex_sigil(advance(Lexer, Source@52));

        _ ->
            case gleam_stdlib:string_pop_grapheme(erlang:element(2, Lexer)) of
                {error, _} ->
                    {Lexer, end_of_file};

                {ok, {Char@3, Source@53}} ->
                    {advance(
                            error(Lexer, {unknown_character, Char@3}),
                            Source@53
                        ),
                        {unknown, Char@3}}
            end
    end.

-file("src/pearl.gleam", 90).
-spec do_tokenise(lexer(), list(pearl@token:token())) -> {list(pearl@token:token()),
    list(error())}.
do_tokenise(Lexer, Tokens) ->
    case next(Lexer) of
        {Lexer@1, end_of_file} ->
            {lists:reverse([end_of_file | Tokens]),
                lists:reverse(erlang:element(5, Lexer@1))};

        {Lexer@2, Token} ->
            do_tokenise(Lexer@2, [Token | Tokens])
    end.

-file("src/pearl.gleam", 82).
-spec tokenise(lexer()) -> {list(pearl@token:token()), list(error())}.
tokenise(Lexer) ->
    do_tokenise(Lexer, []).

-file("src/pearl.gleam", 1016).
-spec lex_whitespace(lexer(), binary()) -> {lexer(), pearl@token:token()}.
lex_whitespace(Lexer, Lexed) ->
    case erlang:element(2, Lexer) of
        <<Space:1/binary, Source/binary>> when Space =:= <<" "/utf8>> ->
            lex_whitespace(
                advance(Lexer, Source),
                <<Lexed/binary, Space/binary>>
            );

        <<Space:1/binary, Source/binary>> when Space =:= <<"\n"/utf8>> ->
            lex_whitespace(
                advance(Lexer, Source),
                <<Lexed/binary, Space/binary>>
            );

        <<Space:1/binary, Source/binary>> when Space =:= <<"\r"/utf8>> ->
            lex_whitespace(
                advance(Lexer, Source),
                <<Lexed/binary, Space/binary>>
            );

        <<Space:1/binary, Source/binary>> when Space =:= <<"\t"/utf8>> ->
            lex_whitespace(
                advance(Lexer, Source),
                <<Lexed/binary, Space/binary>>
            );

        <<Space:1/binary, Source/binary>> when Space =:= <<"\f"/utf8>> ->
            lex_whitespace(
                advance(Lexer, Source),
                <<Lexed/binary, Space/binary>>
            );

        _ ->
            maybe_token(
                Lexer,
                {whitespace, Lexed},
                not erlang:element(4, Lexer)
            )
    end.