-module(cel@parser@lexer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/1, discard_whitespace/1, discard_comments/1, lex/1]).
-export_type([token/0, position/0, lexer/0, number_lexer_mode/0]).

-type token() :: {ident, binary()} |
    {int, binary()} |
    {u_int, binary()} |
    {float, binary()} |
    {string, binary()} |
    {bytes, bitstring()} |
    {bool, boolean()} |
    null |
    plus |
    minus |
    star |
    slash |
    percent |
    less_than |
    less_than_eq |
    greater_than |
    greater_than_eq |
    equals |
    not_equals |
    in |
    'or' |
    'and' |
    left_paren |
    right_paren |
    left_curly |
    right_curly |
    left_square |
    right_square |
    at |
    dot |
    colon |
    semi_colon |
    comma |
    exclamation_mark |
    hash |
    question_mark |
    {comment, binary()} |
    {whitespace, binary()} |
    end_of_file |
    {reserved, binary()} |
    {unterminated_string, binary()} |
    {unterminated_bytes, bitstring()} |
    {unexpected_grapheme, binary()} |
    {invalid_byte_literal, binary()}.

-type position() :: {position, integer(), integer()}.

-opaque lexer() :: {lexer, binary(), integer(), boolean(), boolean()}.

-type number_lexer_mode() :: lex_int | lex_float | lex_float_exponent.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 86).
-spec new(binary()) -> lexer().
new(Source) ->
    {lexer, Source, 0, true, true}.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 95).
-spec discard_whitespace(lexer()) -> lexer().
discard_whitespace(Lexer) ->
    erlang:setelement(4, Lexer, false).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 99).
-spec discard_comments(lexer()) -> lexer().
discard_comments(Lexer) ->
    erlang:setelement(5, Lexer, false).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 175).
-spec byte_size(binary()) -> integer().
byte_size(String) ->
    erlang:byte_size(<<String/binary>>).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 379).
-spec take_content(binary(), binary(), fun((binary()) -> boolean())) -> {binary(),
    binary()}.
take_content(Source, Content, Predicate) ->
    case gleam_stdlib:string_pop_grapheme(Source) of
        {error, _} ->
            {Content, <<""/utf8>>};

        {ok, {Grapheme, Rest}} ->
            case Predicate(Grapheme) of
                true ->
                    take_content(
                        Rest,
                        <<Content/binary, Grapheme/binary>>,
                        Predicate
                    );

                false ->
                    {Content, Source}
            end
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 395).
-spec advance(lexer(), binary(), integer()) -> lexer().
advance(Lexer, Source, Offset) ->
    erlang:setelement(
        3,
        erlang:setelement(2, Lexer, Source),
        erlang:element(3, Lexer) + Offset
    ).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 399).
-spec advanced({token(), position()}, lexer(), binary(), integer()) -> {lexer(),
    {token(), position()}}.
advanced(Token, Lexer, Source, Offset) ->
    {advance(Lexer, Source, Offset), Token}.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 408).
-spec token(lexer(), token(), integer()) -> {token(), position()}.
token(Lexer, Token, Size) ->
    {Token, {position, erlang:element(3, Lexer), Size}}.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 412).
-spec lex_string(lexer(), binary(), binary(), integer(), boolean()) -> {lexer(),
    {token(), position()}}.
lex_string(Lexer, Content, Init, Start, Raw) ->
    case {erlang:element(2, Lexer), Init, Raw} of
        {<<"\"\"\""/utf8, Rest/binary>>, <<"\"\"\""/utf8>>, _} ->
            Size = case Raw of
                true ->
                    byte_size(Content) + 7;

                false ->
                    byte_size(Content) + 6
            end,
            _pipe = {{string, Content}, {position, Start, Size}},
            advanced(_pipe, Lexer, Rest, 3);

        {<<"'''"/utf8, Rest/binary>>, <<"'''"/utf8>>, _} ->
            Size = case Raw of
                true ->
                    byte_size(Content) + 7;

                false ->
                    byte_size(Content) + 6
            end,
            _pipe = {{string, Content}, {position, Start, Size}},
            advanced(_pipe, Lexer, Rest, 3);

        {<<"\""/utf8, Rest@1/binary>>, <<"\""/utf8>>, _} ->
            Size@1 = case Raw of
                true ->
                    byte_size(Content) + 3;

                false ->
                    byte_size(Content) + 2
            end,
            _pipe@1 = {{string, Content}, {position, Start, Size@1}},
            advanced(_pipe@1, Lexer, Rest@1, 1);

        {<<"'"/utf8, Rest@1/binary>>, <<"'"/utf8>>, _} ->
            Size@1 = case Raw of
                true ->
                    byte_size(Content) + 3;

                false ->
                    byte_size(Content) + 2
            end,
            _pipe@1 = {{string, Content}, {position, Start, Size@1}},
            advanced(_pipe@1, Lexer, Rest@1, 1);

        {<<"\\"/utf8, Rest@2/binary>>, _, false} ->
            case gleam_stdlib:string_pop_grapheme(Rest@2) of
                {error, _} ->
                    _pipe@2 = advance(Lexer, Rest@2, 1),
                    lex_string(
                        _pipe@2,
                        <<Content/binary, "\\"/utf8>>,
                        Init,
                        Start,
                        Raw
                    );

                {ok, {G, Rest@3}} ->
                    Offset = erlang:byte_size(G) + 1,
                    _pipe@3 = advance(Lexer, Rest@3, Offset),
                    lex_string(
                        _pipe@3,
                        <<Content/binary, G/binary>>,
                        Init,
                        Start,
                        Raw
                    )
            end;

        {_, _, _} ->
            case gleam_stdlib:string_pop_grapheme(erlang:element(2, Lexer)) of
                {ok, {G@1, Rest@4}} ->
                    _pipe@4 = advance(Lexer, Rest@4, erlang:byte_size(G@1)),
                    lex_string(
                        _pipe@4,
                        <<Content/binary, G@1/binary>>,
                        Init,
                        Start,
                        Raw
                    );

                {error, _} ->
                    {Lexer,
                        {{unterminated_string, Content}, {position, Start, 0}}}
            end
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 471).
-spec lex_bytes(lexer(), bitstring(), binary(), integer()) -> {lexer(),
    {token(), position()}}.
lex_bytes(Lexer, Content, Init, Start) ->
    case {erlang:element(2, Lexer), Init} of
        {<<"\""/utf8, Rest/binary>>, <<"\""/utf8>>} ->
            Size = erlang:byte_size(Content) + 3,
            _pipe = {{bytes, Content}, {position, Start, Size}},
            advanced(_pipe, Lexer, Rest, 3);

        {<<"'"/utf8, Rest/binary>>, <<"'"/utf8>>} ->
            Size = erlang:byte_size(Content) + 3,
            _pipe = {{bytes, Content}, {position, Start, Size}},
            advanced(_pipe, Lexer, Rest, 3);

        {<<"\\"/utf8, Rest@1/binary>>, _} ->
            case Rest@1 of
                <<"x"/utf8, Rest@2/binary>> ->
                    Hex_digits = gleam@string:slice(Rest@2, 0, 2),
                    Rest@3 = gleam@string:drop_start(Rest@2, 2),
                    Byte_size = erlang:byte_size(Hex_digits),
                    Lexer@1 = advance(Lexer, Rest@3, Byte_size + 2),
                    Invalid = {Lexer@1,
                        {{invalid_byte_literal,
                                <<"\\x"/utf8, Hex_digits/binary>>},
                            {position, Start, 0}}},
                    gleam@bool:guard(
                        Byte_size /= 2,
                        Invalid,
                        fun() -> _pipe@1 = gleam@int:base_parse(Hex_digits, 16),
                            _pipe@2 = gleam@result:replace_error(
                                _pipe@1,
                                Invalid
                            ),
                            _pipe@3 = gleam@result:map(
                                _pipe@2,
                                fun(Value) ->
                                    lex_bytes(
                                        Lexer@1,
                                        gleam@bit_array:append(
                                            Content,
                                            <<Value>>
                                        ),
                                        Init,
                                        Start
                                    )
                                end
                            ),
                            gleam@result:unwrap_both(_pipe@3) end
                    );

                <<"X"/utf8, Rest@2/binary>> ->
                    Hex_digits = gleam@string:slice(Rest@2, 0, 2),
                    Rest@3 = gleam@string:drop_start(Rest@2, 2),
                    Byte_size = erlang:byte_size(Hex_digits),
                    Lexer@1 = advance(Lexer, Rest@3, Byte_size + 2),
                    Invalid = {Lexer@1,
                        {{invalid_byte_literal,
                                <<"\\x"/utf8, Hex_digits/binary>>},
                            {position, Start, 0}}},
                    gleam@bool:guard(
                        Byte_size /= 2,
                        Invalid,
                        fun() -> _pipe@1 = gleam@int:base_parse(Hex_digits, 16),
                            _pipe@2 = gleam@result:replace_error(
                                _pipe@1,
                                Invalid
                            ),
                            _pipe@3 = gleam@result:map(
                                _pipe@2,
                                fun(Value) ->
                                    lex_bytes(
                                        Lexer@1,
                                        gleam@bit_array:append(
                                            Content,
                                            <<Value>>
                                        ),
                                        Init,
                                        Start
                                    )
                                end
                            ),
                            gleam@result:unwrap_both(_pipe@3) end
                    );

                _ ->
                    Octet_digits = gleam@string:slice(Rest@1, 0, 3),
                    Rest@4 = gleam@string:drop_start(Rest@1, 3),
                    Byte_size@1 = erlang:byte_size(Octet_digits),
                    Lexer@2 = advance(Lexer, Rest@4, Byte_size@1 + 1),
                    Invalid@1 = {Lexer@2,
                        {{invalid_byte_literal,
                                <<"\\"/utf8, Octet_digits/binary>>},
                            {position, Start, 0}}},
                    gleam@bool:guard(
                        Byte_size@1 /= 3,
                        Invalid@1,
                        fun() ->
                            _pipe@4 = gleam@int:base_parse(Octet_digits, 8),
                            _pipe@5 = gleam@result:replace_error(
                                _pipe@4,
                                Invalid@1
                            ),
                            _pipe@6 = gleam@result:map(
                                _pipe@5,
                                fun(Value@1) ->
                                    lex_bytes(
                                        Lexer@2,
                                        gleam@bit_array:append(
                                            Content,
                                            <<Value@1>>
                                        ),
                                        Init,
                                        Start
                                    )
                                end
                            ),
                            gleam@result:unwrap_both(_pipe@6)
                        end
                    )
            end;

        {_, _} ->
            case gleam_stdlib:string_pop_grapheme(erlang:element(2, Lexer)) of
                {ok, {G, Rest@5}} ->
                    Content@1 = gleam@bit_array:append(Content, <<G/binary>>),
                    _pipe@7 = advance(Lexer, Rest@5, erlang:byte_size(G)),
                    lex_bytes(_pipe@7, Content@1, Init, Start);

                {error, _} ->
                    {Lexer,
                        {{unterminated_bytes, Content}, {position, Start, 0}}}
            end
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 560).
-spec lex_number(lexer(), binary(), number_lexer_mode(), integer()) -> {lexer(),
    {token(), position()}}.
lex_number(Lexer, Content, Mode, Start) ->
    case erlang:element(2, Lexer) of
        <<"."/utf8, Rest/binary>> when Mode =:= lex_int ->
            _pipe = advance(Lexer, Rest, 1),
            lex_number(_pipe, <<Content/binary, "."/utf8>>, lex_float, Start);

        <<"e-"/utf8, Rest@1/binary>> when Mode =:= lex_float ->
            _pipe@1 = advance(Lexer, Rest@1, 1),
            lex_number(
                _pipe@1,
                <<Content/binary, "e-"/utf8>>,
                lex_float_exponent,
                Start
            );

        <<"e"/utf8, Rest@2/binary>> when Mode =:= lex_float ->
            _pipe@2 = advance(Lexer, Rest@2, 1),
            lex_number(
                _pipe@2,
                <<Content/binary, "e"/utf8>>,
                lex_float_exponent,
                Start
            );

        <<"_"/utf8, Source/binary>> ->
            _pipe@3 = advance(Lexer, Source, 1),
            lex_number(_pipe@3, <<Content/binary, "_"/utf8>>, Mode, Start);

        <<"0"/utf8, Source@1/binary>> ->
            _pipe@4 = advance(Lexer, Source@1, 1),
            lex_number(_pipe@4, <<Content/binary, "0"/utf8>>, Mode, Start);

        <<"1"/utf8, Source@2/binary>> ->
            _pipe@5 = advance(Lexer, Source@2, 1),
            lex_number(_pipe@5, <<Content/binary, "1"/utf8>>, Mode, Start);

        <<"2"/utf8, Source@3/binary>> ->
            _pipe@6 = advance(Lexer, Source@3, 1),
            lex_number(_pipe@6, <<Content/binary, "2"/utf8>>, Mode, Start);

        <<"3"/utf8, Source@4/binary>> ->
            _pipe@7 = advance(Lexer, Source@4, 1),
            lex_number(_pipe@7, <<Content/binary, "3"/utf8>>, Mode, Start);

        <<"4"/utf8, Source@5/binary>> ->
            _pipe@8 = advance(Lexer, Source@5, 1),
            lex_number(_pipe@8, <<Content/binary, "4"/utf8>>, Mode, Start);

        <<"5"/utf8, Source@6/binary>> ->
            _pipe@9 = advance(Lexer, Source@6, 1),
            lex_number(_pipe@9, <<Content/binary, "5"/utf8>>, Mode, Start);

        <<"6"/utf8, Source@7/binary>> ->
            _pipe@10 = advance(Lexer, Source@7, 1),
            lex_number(_pipe@10, <<Content/binary, "6"/utf8>>, Mode, Start);

        <<"7"/utf8, Source@8/binary>> ->
            _pipe@11 = advance(Lexer, Source@8, 1),
            lex_number(_pipe@11, <<Content/binary, "7"/utf8>>, Mode, Start);

        <<"8"/utf8, Source@9/binary>> ->
            _pipe@12 = advance(Lexer, Source@9, 1),
            lex_number(_pipe@12, <<Content/binary, "8"/utf8>>, Mode, Start);

        <<"9"/utf8, Source@10/binary>> ->
            _pipe@13 = advance(Lexer, Source@10, 1),
            lex_number(_pipe@13, <<Content/binary, "9"/utf8>>, Mode, Start);

        <<Suffix:1/binary, Source@11/binary>> when (Suffix =:= <<"u"/utf8>>) andalso (Mode =:= lex_int) ->
            Size = byte_size(<<Content/binary, Suffix/binary>>),
            Lexer@1 = advance(Lexer, Source@11, Size),
            Token = {u_int, <<Content/binary, Suffix/binary>>},
            {Lexer@1, {Token, {position, Start, Size}}};

        <<Suffix:1/binary, Source@11/binary>> when (Suffix =:= <<"U"/utf8>>) andalso (Mode =:= lex_int) ->
            Size = byte_size(<<Content/binary, Suffix/binary>>),
            Lexer@1 = advance(Lexer, Source@11, Size),
            Token = {u_int, <<Content/binary, Suffix/binary>>},
            {Lexer@1, {Token, {position, Start, Size}}};

        Source@12 ->
            Size@1 = byte_size(Content),
            Token@1 = case Mode of
                lex_int ->
                    {int, Content};

                lex_float ->
                    {float, Content};

                lex_float_exponent ->
                    {float, Content}
            end,
            _pipe@14 = {Token@1, {position, Start, Size@1}},
            advanced(_pipe@14, Lexer, Source@12, Size@1)
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 623).
-spec lex_binary(lexer(), binary(), integer()) -> {lexer(),
    {token(), position()}}.
lex_binary(Lexer, Content, Start) ->
    case erlang:element(2, Lexer) of
        <<"_"/utf8, Source/binary>> ->
            _pipe = advance(Lexer, Source, 1),
            lex_binary(_pipe, <<Content/binary, "_"/utf8>>, Start);

        <<"0"/utf8, Source@1/binary>> ->
            _pipe@1 = advance(Lexer, Source@1, 1),
            lex_binary(_pipe@1, <<Content/binary, "0"/utf8>>, Start);

        <<"1"/utf8, Source@2/binary>> ->
            _pipe@2 = advance(Lexer, Source@2, 1),
            lex_binary(_pipe@2, <<Content/binary, "1"/utf8>>, Start);

        Source@3 ->
            Size = byte_size(Content),
            _pipe@3 = {{int, Content}, {position, Start, Size}},
            advanced(_pipe@3, Lexer, Source@3, Size)
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 642).
-spec lex_octal(lexer(), binary(), integer()) -> {lexer(),
    {token(), position()}}.
lex_octal(Lexer, Content, Start) ->
    case erlang:element(2, Lexer) of
        <<"_"/utf8, Source/binary>> ->
            _pipe = advance(Lexer, Source, 1),
            lex_octal(_pipe, <<Content/binary, "_"/utf8>>, Start);

        <<"0"/utf8, Source@1/binary>> ->
            _pipe@1 = advance(Lexer, Source@1, 1),
            lex_octal(_pipe@1, <<Content/binary, "0"/utf8>>, Start);

        <<"1"/utf8, Source@2/binary>> ->
            _pipe@2 = advance(Lexer, Source@2, 1),
            lex_octal(_pipe@2, <<Content/binary, "1"/utf8>>, Start);

        <<"2"/utf8, Source@3/binary>> ->
            _pipe@3 = advance(Lexer, Source@3, 1),
            lex_octal(_pipe@3, <<Content/binary, "2"/utf8>>, Start);

        <<"3"/utf8, Source@4/binary>> ->
            _pipe@4 = advance(Lexer, Source@4, 1),
            lex_octal(_pipe@4, <<Content/binary, "3"/utf8>>, Start);

        <<"4"/utf8, Source@5/binary>> ->
            _pipe@5 = advance(Lexer, Source@5, 1),
            lex_octal(_pipe@5, <<Content/binary, "4"/utf8>>, Start);

        <<"5"/utf8, Source@6/binary>> ->
            _pipe@6 = advance(Lexer, Source@6, 1),
            lex_octal(_pipe@6, <<Content/binary, "5"/utf8>>, Start);

        <<"6"/utf8, Source@7/binary>> ->
            _pipe@7 = advance(Lexer, Source@7, 1),
            lex_octal(_pipe@7, <<Content/binary, "6"/utf8>>, Start);

        <<"7"/utf8, Source@8/binary>> ->
            _pipe@8 = advance(Lexer, Source@8, 1),
            lex_octal(_pipe@8, <<Content/binary, "7"/utf8>>, Start);

        Source@9 ->
            Size = byte_size(Content),
            _pipe@9 = {{int, Content}, {position, Start, Size}},
            advanced(_pipe@9, Lexer, Source@9, Size)
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 673).
-spec lex_hexadecimal(lexer(), binary(), integer()) -> {lexer(),
    {token(), position()}}.
lex_hexadecimal(Lexer, Content, Start) ->
    case erlang:element(2, Lexer) of
        <<"_"/utf8, Source/binary>> ->
            _pipe = advance(Lexer, Source, 1),
            lex_hexadecimal(_pipe, <<Content/binary, "_"/utf8>>, Start);

        <<"0"/utf8, Source@1/binary>> ->
            _pipe@1 = advance(Lexer, Source@1, 1),
            lex_hexadecimal(_pipe@1, <<Content/binary, "0"/utf8>>, Start);

        <<"1"/utf8, Source@2/binary>> ->
            _pipe@2 = advance(Lexer, Source@2, 1),
            lex_hexadecimal(_pipe@2, <<Content/binary, "1"/utf8>>, Start);

        <<"2"/utf8, Source@3/binary>> ->
            _pipe@3 = advance(Lexer, Source@3, 1),
            lex_hexadecimal(_pipe@3, <<Content/binary, "2"/utf8>>, Start);

        <<"3"/utf8, Source@4/binary>> ->
            _pipe@4 = advance(Lexer, Source@4, 1),
            lex_hexadecimal(_pipe@4, <<Content/binary, "3"/utf8>>, Start);

        <<"4"/utf8, Source@5/binary>> ->
            _pipe@5 = advance(Lexer, Source@5, 1),
            lex_hexadecimal(_pipe@5, <<Content/binary, "4"/utf8>>, Start);

        <<"5"/utf8, Source@6/binary>> ->
            _pipe@6 = advance(Lexer, Source@6, 1),
            lex_hexadecimal(_pipe@6, <<Content/binary, "5"/utf8>>, Start);

        <<"6"/utf8, Source@7/binary>> ->
            _pipe@7 = advance(Lexer, Source@7, 1),
            lex_hexadecimal(_pipe@7, <<Content/binary, "6"/utf8>>, Start);

        <<"7"/utf8, Source@8/binary>> ->
            _pipe@8 = advance(Lexer, Source@8, 1),
            lex_hexadecimal(_pipe@8, <<Content/binary, "7"/utf8>>, Start);

        <<"8"/utf8, Source@9/binary>> ->
            _pipe@9 = advance(Lexer, Source@9, 1),
            lex_hexadecimal(_pipe@9, <<Content/binary, "8"/utf8>>, Start);

        <<"9"/utf8, Source@10/binary>> ->
            _pipe@10 = advance(Lexer, Source@10, 1),
            lex_hexadecimal(_pipe@10, <<Content/binary, "9"/utf8>>, Start);

        <<"A"/utf8, Source@11/binary>> ->
            _pipe@11 = advance(Lexer, Source@11, 1),
            lex_hexadecimal(_pipe@11, <<Content/binary, "A"/utf8>>, Start);

        <<"B"/utf8, Source@12/binary>> ->
            _pipe@12 = advance(Lexer, Source@12, 1),
            lex_hexadecimal(_pipe@12, <<Content/binary, "B"/utf8>>, Start);

        <<"C"/utf8, Source@13/binary>> ->
            _pipe@13 = advance(Lexer, Source@13, 1),
            lex_hexadecimal(_pipe@13, <<Content/binary, "C"/utf8>>, Start);

        <<"D"/utf8, Source@14/binary>> ->
            _pipe@14 = advance(Lexer, Source@14, 1),
            lex_hexadecimal(_pipe@14, <<Content/binary, "D"/utf8>>, Start);

        <<"E"/utf8, Source@15/binary>> ->
            _pipe@15 = advance(Lexer, Source@15, 1),
            lex_hexadecimal(_pipe@15, <<Content/binary, "E"/utf8>>, Start);

        <<"F"/utf8, Source@16/binary>> ->
            _pipe@16 = advance(Lexer, Source@16, 1),
            lex_hexadecimal(_pipe@16, <<Content/binary, "F"/utf8>>, Start);

        <<"a"/utf8, Source@17/binary>> ->
            _pipe@17 = advance(Lexer, Source@17, 1),
            lex_hexadecimal(_pipe@17, <<Content/binary, "a"/utf8>>, Start);

        <<"b"/utf8, Source@18/binary>> ->
            _pipe@18 = advance(Lexer, Source@18, 1),
            lex_hexadecimal(_pipe@18, <<Content/binary, "b"/utf8>>, Start);

        <<"c"/utf8, Source@19/binary>> ->
            _pipe@19 = advance(Lexer, Source@19, 1),
            lex_hexadecimal(_pipe@19, <<Content/binary, "c"/utf8>>, Start);

        <<"d"/utf8, Source@20/binary>> ->
            _pipe@20 = advance(Lexer, Source@20, 1),
            lex_hexadecimal(_pipe@20, <<Content/binary, "d"/utf8>>, Start);

        <<"e"/utf8, Source@21/binary>> ->
            _pipe@21 = advance(Lexer, Source@21, 1),
            lex_hexadecimal(_pipe@21, <<Content/binary, "e"/utf8>>, Start);

        <<"f"/utf8, Source@22/binary>> ->
            _pipe@22 = advance(Lexer, Source@22, 1),
            lex_hexadecimal(_pipe@22, <<Content/binary, "f"/utf8>>, Start);

        Source@23 ->
            Size = byte_size(Content),
            _pipe@23 = {{int, Content}, {position, Start, Size}},
            advanced(_pipe@23, Lexer, Source@23, Size)
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 732).
-spec is_ident_grapheme(binary()) -> boolean().
is_ident_grapheme(Grapheme) ->
    case Grapheme of
        <<"a"/utf8>> ->
            true;

        <<"b"/utf8>> ->
            true;

        <<"c"/utf8>> ->
            true;

        <<"d"/utf8>> ->
            true;

        <<"e"/utf8>> ->
            true;

        <<"f"/utf8>> ->
            true;

        <<"g"/utf8>> ->
            true;

        <<"h"/utf8>> ->
            true;

        <<"i"/utf8>> ->
            true;

        <<"j"/utf8>> ->
            true;

        <<"k"/utf8>> ->
            true;

        <<"l"/utf8>> ->
            true;

        <<"m"/utf8>> ->
            true;

        <<"n"/utf8>> ->
            true;

        <<"o"/utf8>> ->
            true;

        <<"p"/utf8>> ->
            true;

        <<"q"/utf8>> ->
            true;

        <<"r"/utf8>> ->
            true;

        <<"s"/utf8>> ->
            true;

        <<"t"/utf8>> ->
            true;

        <<"u"/utf8>> ->
            true;

        <<"v"/utf8>> ->
            true;

        <<"w"/utf8>> ->
            true;

        <<"x"/utf8>> ->
            true;

        <<"y"/utf8>> ->
            true;

        <<"z"/utf8>> ->
            true;

        <<"A"/utf8>> ->
            true;

        <<"B"/utf8>> ->
            true;

        <<"C"/utf8>> ->
            true;

        <<"D"/utf8>> ->
            true;

        <<"E"/utf8>> ->
            true;

        <<"F"/utf8>> ->
            true;

        <<"G"/utf8>> ->
            true;

        <<"H"/utf8>> ->
            true;

        <<"I"/utf8>> ->
            true;

        <<"J"/utf8>> ->
            true;

        <<"K"/utf8>> ->
            true;

        <<"L"/utf8>> ->
            true;

        <<"M"/utf8>> ->
            true;

        <<"N"/utf8>> ->
            true;

        <<"O"/utf8>> ->
            true;

        <<"P"/utf8>> ->
            true;

        <<"Q"/utf8>> ->
            true;

        <<"R"/utf8>> ->
            true;

        <<"S"/utf8>> ->
            true;

        <<"T"/utf8>> ->
            true;

        <<"U"/utf8>> ->
            true;

        <<"V"/utf8>> ->
            true;

        <<"W"/utf8>> ->
            true;

        <<"X"/utf8>> ->
            true;

        <<"Y"/utf8>> ->
            true;

        <<"Z"/utf8>> ->
            true;

        <<"0"/utf8>> ->
            true;

        <<"1"/utf8>> ->
            true;

        <<"2"/utf8>> ->
            true;

        <<"3"/utf8>> ->
            true;

        <<"4"/utf8>> ->
            true;

        <<"5"/utf8>> ->
            true;

        <<"6"/utf8>> ->
            true;

        <<"7"/utf8>> ->
            true;

        <<"8"/utf8>> ->
            true;

        <<"9"/utf8>> ->
            true;

        <<"_"/utf8>> ->
            true;

        _ ->
            false
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 115).
-spec comment(lexer(), binary(), integer()) -> {lexer(), {token(), position()}}.
comment(Lexer, Content, Start) ->
    case erlang:element(2, Lexer) of
        <<"\n"/utf8, _/binary>> ->
            case erlang:element(5, Lexer) of
                true ->
                    {Lexer,
                        {{comment, Content},
                            {position, Start, erlang:byte_size(Content)}}};

                false ->
                    next(Lexer)
            end;

        <<"\r\n"/utf8, _/binary>> ->
            case erlang:element(5, Lexer) of
                true ->
                    {Lexer,
                        {{comment, Content},
                            {position, Start, erlang:byte_size(Content)}}};

                false ->
                    next(Lexer)
            end;

        _ ->
            case gleam_stdlib:string_pop_grapheme(erlang:element(2, Lexer)) of
                {error, _} ->
                    case erlang:element(5, Lexer) of
                        true ->
                            {Lexer,
                                {{comment, Content},
                                    {position, Start, erlang:byte_size(Content)}}};

                        false ->
                            next(Lexer)
                    end;

                {ok, {G, Rest}} ->
                    _pipe = advance(Lexer, Rest, erlang:byte_size(G)),
                    comment(_pipe, <<Content/binary, G/binary>>, Start)
            end
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 179).
-spec next(lexer()) -> {lexer(), {token(), position()}}.
next(Lexer) ->
    case erlang:element(2, Lexer) of
        <<" "/utf8, Rest/binary>> ->
            _pipe = advance(Lexer, Rest, 1),
            whitespace(_pipe, Rest, 1);

        <<"\t"/utf8, Rest/binary>> ->
            _pipe = advance(Lexer, Rest, 1),
            whitespace(_pipe, Rest, 1);

        <<"\n"/utf8, Rest/binary>> ->
            _pipe = advance(Lexer, Rest, 1),
            whitespace(_pipe, Rest, 1);

        <<"\r"/utf8, Rest/binary>> ->
            _pipe = advance(Lexer, Rest, 1),
            whitespace(_pipe, Rest, 1);

        <<"//"/utf8, Rest@1/binary>> ->
            _pipe@1 = advance(Lexer, Rest@1, 2),
            comment(_pipe@1, Rest@1, erlang:element(3, Lexer));

        <<"("/utf8, Rest@2/binary>> ->
            {advance(Lexer, Rest@2, 1), token(Lexer, left_paren, 1)};

        <<")"/utf8, Rest@3/binary>> ->
            {advance(Lexer, Rest@3, 1), token(Lexer, right_paren, 1)};

        <<"{"/utf8, Rest@4/binary>> ->
            {advance(Lexer, Rest@4, 1), token(Lexer, left_curly, 1)};

        <<"}"/utf8, Rest@5/binary>> ->
            {advance(Lexer, Rest@5, 1), token(Lexer, right_curly, 1)};

        <<"["/utf8, Rest@6/binary>> ->
            {advance(Lexer, Rest@6, 1), token(Lexer, left_square, 1)};

        <<"]"/utf8, Rest@7/binary>> ->
            {advance(Lexer, Rest@7, 1), token(Lexer, right_square, 1)};

        <<"@"/utf8, Rest@8/binary>> ->
            {advance(Lexer, Rest@8, 1), token(Lexer, at, 1)};

        <<":"/utf8, Rest@9/binary>> ->
            {advance(Lexer, Rest@9, 1), token(Lexer, colon, 1)};

        <<"?"/utf8, Rest@10/binary>> ->
            {advance(Lexer, Rest@10, 1), token(Lexer, question_mark, 1)};

        <<","/utf8, Rest@11/binary>> ->
            {advance(Lexer, Rest@11, 1), token(Lexer, comma, 1)};

        <<"."/utf8, Rest@12/binary>> ->
            {advance(Lexer, Rest@12, 1), token(Lexer, dot, 1)};

        <<"#"/utf8, Rest@13/binary>> ->
            {advance(Lexer, Rest@13, 1), token(Lexer, hash, 1)};

        <<"!"/utf8, Rest@14/binary>> ->
            {advance(Lexer, Rest@14, 1), token(Lexer, exclamation_mark, 1)};

        <<"!="/utf8, Rest@15/binary>> ->
            {advance(Lexer, Rest@15, 2), token(Lexer, not_equals, 2)};

        <<"=="/utf8, Rest@16/binary>> ->
            {advance(Lexer, Rest@16, 2), token(Lexer, equals, 2)};

        <<"||"/utf8, Rest@17/binary>> ->
            {advance(Lexer, Rest@17, 2), token(Lexer, 'or', 2)};

        <<"&&"/utf8, Rest@18/binary>> ->
            {advance(Lexer, Rest@18, 2), token(Lexer, 'and', 2)};

        <<"<="/utf8, Rest@19/binary>> ->
            {advance(Lexer, Rest@19, 2), token(Lexer, less_than_eq, 2)};

        <<"<"/utf8, Rest@20/binary>> ->
            {advance(Lexer, Rest@20, 1), token(Lexer, less_than, 1)};

        <<">="/utf8, Rest@21/binary>> ->
            {advance(Lexer, Rest@21, 2), token(Lexer, greater_than_eq, 2)};

        <<">"/utf8, Rest@22/binary>> ->
            {advance(Lexer, Rest@22, 1), token(Lexer, greater_than, 1)};

        <<"+"/utf8, Rest@23/binary>> ->
            {advance(Lexer, Rest@23, 1), token(Lexer, plus, 1)};

        <<"-"/utf8, Rest@24/binary>> ->
            {advance(Lexer, Rest@24, 1), token(Lexer, minus, 1)};

        <<"*"/utf8, Rest@25/binary>> ->
            {advance(Lexer, Rest@25, 1), token(Lexer, star, 1)};

        <<"/"/utf8, Rest@26/binary>> ->
            {advance(Lexer, Rest@26, 1), token(Lexer, slash, 1)};

        <<"%"/utf8, Rest@27/binary>> ->
            {advance(Lexer, Rest@27, 1), token(Lexer, percent, 1)};

        <<"r\"\"\""/utf8, Rest@28/binary>> ->
            _pipe@2 = advance(Lexer, Rest@28, 4),
            lex_string(
                _pipe@2,
                <<""/utf8>>,
                <<"\"\"\""/utf8>>,
                erlang:element(3, Lexer),
                true
            );

        <<"R\"\"\""/utf8, Rest@28/binary>> ->
            _pipe@2 = advance(Lexer, Rest@28, 4),
            lex_string(
                _pipe@2,
                <<""/utf8>>,
                <<"\"\"\""/utf8>>,
                erlang:element(3, Lexer),
                true
            );

        <<"r'''"/utf8, Rest@29/binary>> ->
            _pipe@3 = advance(Lexer, Rest@29, 4),
            lex_string(
                _pipe@3,
                <<""/utf8>>,
                <<"'''"/utf8>>,
                erlang:element(3, Lexer),
                true
            );

        <<"R'''"/utf8, Rest@29/binary>> ->
            _pipe@3 = advance(Lexer, Rest@29, 4),
            lex_string(
                _pipe@3,
                <<""/utf8>>,
                <<"'''"/utf8>>,
                erlang:element(3, Lexer),
                true
            );

        <<"r\""/utf8, Rest@30/binary>> ->
            _pipe@4 = advance(Lexer, Rest@30, 2),
            lex_string(
                _pipe@4,
                <<""/utf8>>,
                <<"\""/utf8>>,
                erlang:element(3, Lexer),
                true
            );

        <<"R\""/utf8, Rest@30/binary>> ->
            _pipe@4 = advance(Lexer, Rest@30, 2),
            lex_string(
                _pipe@4,
                <<""/utf8>>,
                <<"\""/utf8>>,
                erlang:element(3, Lexer),
                true
            );

        <<"r'"/utf8, Rest@31/binary>> ->
            _pipe@5 = advance(Lexer, Rest@31, 2),
            lex_string(
                _pipe@5,
                <<""/utf8>>,
                <<"'"/utf8>>,
                erlang:element(3, Lexer),
                true
            );

        <<"R'"/utf8, Rest@31/binary>> ->
            _pipe@5 = advance(Lexer, Rest@31, 2),
            lex_string(
                _pipe@5,
                <<""/utf8>>,
                <<"'"/utf8>>,
                erlang:element(3, Lexer),
                true
            );

        <<"b\""/utf8, Rest@32/binary>> ->
            _pipe@6 = advance(Lexer, Rest@32, 2),
            lex_bytes(_pipe@6, <<>>, <<"\""/utf8>>, erlang:element(3, Lexer));

        <<"\"\"\""/utf8, Rest@33/binary>> ->
            _pipe@7 = advance(Lexer, Rest@33, 3),
            lex_string(
                _pipe@7,
                <<""/utf8>>,
                <<"\"\"\""/utf8>>,
                erlang:element(3, Lexer),
                false
            );

        <<"'''"/utf8, Rest@34/binary>> ->
            _pipe@8 = advance(Lexer, Rest@34, 3),
            lex_string(
                _pipe@8,
                <<""/utf8>>,
                <<"'''"/utf8>>,
                erlang:element(3, Lexer),
                false
            );

        <<"\""/utf8, Rest@35/binary>> ->
            _pipe@9 = advance(Lexer, Rest@35, 1),
            lex_string(
                _pipe@9,
                <<""/utf8>>,
                <<"\""/utf8>>,
                erlang:element(3, Lexer),
                false
            );

        <<"'"/utf8, Rest@36/binary>> ->
            _pipe@10 = advance(Lexer, Rest@36, 1),
            lex_string(
                _pipe@10,
                <<""/utf8>>,
                <<"'"/utf8>>,
                erlang:element(3, Lexer),
                false
            );

        <<"0b"/utf8, Source/binary>> ->
            _pipe@11 = advance(Lexer, Source, 1),
            lex_binary(_pipe@11, <<"0b"/utf8>>, erlang:element(3, Lexer));

        <<"0o"/utf8, Source@1/binary>> ->
            _pipe@12 = advance(Lexer, Source@1, 1),
            lex_octal(_pipe@12, <<"0o"/utf8>>, erlang:element(3, Lexer));

        <<"0x"/utf8, Source@2/binary>> ->
            _pipe@13 = advance(Lexer, Source@2, 1),
            lex_hexadecimal(_pipe@13, <<"0x"/utf8>>, erlang:element(3, Lexer));

        <<"0"/utf8, Source@3/binary>> ->
            _pipe@14 = advance(Lexer, Source@3, 1),
            lex_number(
                _pipe@14,
                <<"0"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"1"/utf8, Source@4/binary>> ->
            _pipe@15 = advance(Lexer, Source@4, 1),
            lex_number(
                _pipe@15,
                <<"1"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"2"/utf8, Source@5/binary>> ->
            _pipe@16 = advance(Lexer, Source@5, 1),
            lex_number(
                _pipe@16,
                <<"2"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"3"/utf8, Source@6/binary>> ->
            _pipe@17 = advance(Lexer, Source@6, 1),
            lex_number(
                _pipe@17,
                <<"3"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"4"/utf8, Source@7/binary>> ->
            _pipe@18 = advance(Lexer, Source@7, 1),
            lex_number(
                _pipe@18,
                <<"4"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"5"/utf8, Source@8/binary>> ->
            _pipe@19 = advance(Lexer, Source@8, 1),
            lex_number(
                _pipe@19,
                <<"5"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"6"/utf8, Source@9/binary>> ->
            _pipe@20 = advance(Lexer, Source@9, 1),
            lex_number(
                _pipe@20,
                <<"6"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"7"/utf8, Source@10/binary>> ->
            _pipe@21 = advance(Lexer, Source@10, 1),
            lex_number(
                _pipe@21,
                <<"7"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"8"/utf8, Source@11/binary>> ->
            _pipe@22 = advance(Lexer, Source@11, 1),
            lex_number(
                _pipe@22,
                <<"8"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"9"/utf8, Source@12/binary>> ->
            _pipe@23 = advance(Lexer, Source@12, 1),
            lex_number(
                _pipe@23,
                <<"9"/utf8>>,
                lex_int,
                erlang:element(3, Lexer)
            );

        <<"a"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"b"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"c"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"d"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"e"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"f"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"g"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"h"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"i"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"j"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"k"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"l"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"m"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"n"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"o"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"p"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"q"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"r"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"s"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"t"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"u"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"v"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"w"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"x"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"y"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"z"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"A"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"B"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"C"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"D"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"E"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"F"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"G"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"H"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"I"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"J"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"K"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"L"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"M"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"N"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"O"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"P"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"Q"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"R"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"S"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"T"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"U"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"V"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"W"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"X"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"Y"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"Z"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

        <<"_"/utf8, _/binary>> ->
            {Ident, Rest@37} = take_content(
                erlang:element(2, Lexer),
                <<""/utf8>>,
                fun is_ident_grapheme/1
            ),
            As_token = case Ident of
                <<"false"/utf8>> ->
                    {bool, false};

                <<"in"/utf8>> ->
                    in;

                <<"null"/utf8>> ->
                    null;

                <<"true"/utf8>> ->
                    {bool, true};

                <<"as"/utf8>> ->
                    {reserved, <<"as"/utf8>>};

                <<"break"/utf8>> ->
                    {reserved, <<"break"/utf8>>};

                <<"const"/utf8>> ->
                    {reserved, <<"const"/utf8>>};

                <<"continue"/utf8>> ->
                    {reserved, <<"continue"/utf8>>};

                <<"else"/utf8>> ->
                    {reserved, <<"else"/utf8>>};

                <<"for"/utf8>> ->
                    {reserved, <<"for"/utf8>>};

                <<"function"/utf8>> ->
                    {reserved, <<"function"/utf8>>};

                <<"if"/utf8>> ->
                    {reserved, <<"if"/utf8>>};

                <<"import"/utf8>> ->
                    {reserved, <<"import"/utf8>>};

                <<"let"/utf8>> ->
                    {reserved, <<"let"/utf8>>};

                <<"loop"/utf8>> ->
                    {reserved, <<"loop"/utf8>>};

                <<"package"/utf8>> ->
                    {reserved, <<"package"/utf8>>};

                <<"namespace"/utf8>> ->
                    {reserved, <<"namespace"/utf8>>};

                <<"return"/utf8>> ->
                    {reserved, <<"return"/utf8>>};

                <<"var"/utf8>> ->
                    {reserved, <<"var"/utf8>>};

                <<"void"/utf8>> ->
                    {reserved, <<"void"/utf8>>};

                <<"while"/utf8>> ->
                    {reserved, <<"while"/utf8>>};

                Ident@1 ->
                    {ident, Ident@1}
            end,
            Size = byte_size(Ident),
            {erlang:setelement(
                    3,
                    erlang:setelement(2, Lexer, Rest@37),
                    erlang:element(3, Lexer) + Size
                ),
                token(Lexer, As_token, Size)};

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

                {ok, {Grapheme, Rest@38}} ->
                    T = {unexpected_grapheme, Grapheme},
                    Size@1 = byte_size(Grapheme),
                    {advance(Lexer, Rest@38, Size@1), token(Lexer, T, Size@1)}
            end
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 108).
-spec do_lex(lexer(), list({token(), position()})) -> list({token(), position()}).
do_lex(Lexer, Tokens) ->
    case next(Lexer) of
        {_, {end_of_file, _}} ->
            Tokens;

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

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 103).
-spec lex(lexer()) -> list({token(), position()}).
lex(Lexer) ->
    _pipe = do_lex(Lexer, []),
    lists:reverse(_pipe).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/parser/lexer.gleam", 148).
-spec whitespace(lexer(), binary(), integer()) -> {lexer(),
    {token(), position()}}.
whitespace(Lexer, Content, Start) ->
    case erlang:element(2, Lexer) of
        <<C:1/binary, Source/binary>> when C =:= <<" "/utf8>> ->
            _pipe = advance(Lexer, Source, erlang:byte_size(C)),
            whitespace(_pipe, <<Content/binary, C/binary>>, Start);

        <<C:1/binary, Source/binary>> when C =:= <<"\t"/utf8>> ->
            _pipe = advance(Lexer, Source, erlang:byte_size(C)),
            whitespace(_pipe, <<Content/binary, C/binary>>, Start);

        <<C:1/binary, Source/binary>> when C =:= <<"\n"/utf8>> ->
            _pipe = advance(Lexer, Source, erlang:byte_size(C)),
            whitespace(_pipe, <<Content/binary, C/binary>>, Start);

        <<C:1/binary, Source/binary>> when C =:= <<"\r"/utf8>> ->
            _pipe = advance(Lexer, Source, erlang:byte_size(C)),
            whitespace(_pipe, <<Content/binary, C/binary>>, Start);

        _ ->
            case erlang:element(4, Lexer) of
                false ->
                    next(Lexer);

                true ->
                    Size = erlang:byte_size(Content),
                    {Lexer, {{whitespace, Content}, {position, Start, Size}}}
            end
    end.