-module(sqid).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/sqid.gleam").
-export([alphabet/1, new/1, set_minimum_length/2, set_blocklist/2, encode/2, decode/2]).
-export_type([alphabet/0, options/0]).

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

-opaque alphabet() :: {alphabet, gleam@dict:dict(integer(), binary())}.

-opaque options() :: {options, alphabet(), integer(), list(binary())}.

-file("src/sqid.gleam", 406).
?DOC(
    " Given a dictionary of letters this returns the codepoint value of the letter\n"
    " at the given index.\n"
    " This would fail if:\n"
    " - the index is not included in the dictionary\n"
    " - the dictionary value is an empty string\n"
    "\n"
    " We only ever use this internally after validating an alphabet and making\n"
    " sure that all the entries are single letters, so under this assumption it\n"
    " should never fail.\n"
).
-spec letter_value(gleam@dict:dict(integer(), binary()), integer()) -> {ok,
        integer()} |
    {error, nil}.
letter_value(Letters, Index) ->
    _pipe = gleam_stdlib:map_get(Letters, Index),
    _pipe@1 = gleam@result:map(_pipe, fun gleam@string:to_utf_codepoints/1),
    _pipe@2 = gleam@result:'try'(_pipe@1, fun gleam@list:first/1),
    gleam@result:map(_pipe@2, fun gleam_stdlib:identity/1).

-file("src/sqid.gleam", 427).
-spec shuffle_alphabet_loop(
    gleam@dict:dict(integer(), binary()),
    integer(),
    integer()
) -> gleam@dict:dict(integer(), binary()).
shuffle_alphabet_loop(Letters, I, J) ->
    case J =< 0 of
        true ->
            Letters;

        false ->
            I_value@1 = case letter_value(Letters, I) of
                {ok, I_value} -> I_value;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"i always in range"/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"sqid"/utf8>>,
                                function => <<"shuffle_alphabet_loop"/utf8>>,
                                line => 435,
                                value => _assert_fail,
                                start => 14846,
                                'end' => 14895,
                                pattern_start => 14857,
                                pattern_end => 14868})
            end,
            J_value@1 = case letter_value(Letters, J) of
                {ok, J_value} -> J_value;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"j always in range"/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"sqid"/utf8>>,
                                function => <<"shuffle_alphabet_loop"/utf8>>,
                                line => 436,
                                value => _assert_fail@1,
                                start => 14925,
                                'end' => 14974,
                                pattern_start => 14936,
                                pattern_end => 14947})
            end,
            R = case maps:size(Letters) of
                0 -> 0;
                Gleam@denominator -> (((I * J) + I_value@1) + J_value@1) rem Gleam@denominator
            end,
            Old_i@1 = case gleam_stdlib:map_get(Letters, I) of
                {ok, Old_i} -> Old_i;
                _assert_fail@2 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"i always in range"/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"sqid"/utf8>>,
                                function => <<"shuffle_alphabet_loop"/utf8>>,
                                line => 439,
                                value => _assert_fail@2,
                                start => 15070,
                                'end' => 15113,
                                pattern_start => 15081,
                                pattern_end => 15090})
            end,
            Old_r@1 = case gleam_stdlib:map_get(Letters, R) of
                {ok, Old_r} -> Old_r;
                _assert_fail@3 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"r always in range"/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"sqid"/utf8>>,
                                function => <<"shuffle_alphabet_loop"/utf8>>,
                                line => 440,
                                value => _assert_fail@3,
                                start => 15143,
                                'end' => 15186,
                                pattern_start => 15154,
                                pattern_end => 15163})
            end,
            Letters@1 = begin
                _pipe = gleam@dict:insert(Letters, I, Old_r@1),
                gleam@dict:insert(_pipe, R, Old_i@1)
            end,
            shuffle_alphabet_loop(Letters@1, I + 1, J - 1)
    end.

-file("src/sqid.gleam", 421).
?DOC(
    " Shuffles an alphabet.\n"
    " Don't be fooled by the name: the shuffle might look random, but it's\n"
    " actually deterministic. Given an alphabet its shuffled version is always\n"
    " going to be the same.\n"
).
-spec shuffle_alphabet(alphabet()) -> alphabet().
shuffle_alphabet(Alphabet) ->
    Letters = shuffle_alphabet_loop(
        erlang:element(2, Alphabet),
        0,
        maps:size(erlang:element(2, Alphabet)) - 1
    ),
    {alphabet, Letters}.

-file("src/sqid.gleam", 96).
-spec is_multi_byte(binary()) -> boolean().
is_multi_byte(String) ->
    erlang:byte_size(String) > 1.

-file("src/sqid.gleam", 104).
-spec has_duplicates_loop(list(DKX), gleam@set:set(DKX)) -> boolean().
has_duplicates_loop(List, Seen_so_far) ->
    case List of
        [] ->
            false;

        [First | Rest] ->
            case gleam@set:contains(Seen_so_far, First) of
                true ->
                    true;

                false ->
                    has_duplicates_loop(
                        Rest,
                        gleam@set:insert(Seen_so_far, First)
                    )
            end
    end.

-file("src/sqid.gleam", 100).
-spec has_duplicates(list(any())) -> boolean().
has_duplicates(List) ->
    has_duplicates_loop(List, gleam@set:new()).

-file("src/sqid.gleam", 79).
?DOC(
    " Creates a new alphabet from the letters making up the given string.\n"
    " An alphabet is what defines what characters can end up in a generated Sqid.\n"
    "\n"
    " This function will fail if:\n"
    " - The alphabet has less than 3 characters\n"
    " - The alphabet contains repeated characters\n"
    " - The alphabet has multi-byte characters\n"
    "\n"
    " ## Examples\n"
    "\n"
    " If you want Sqids that only contains lowercase letters you can define an\n"
    " alphabet like this:\n"
    "\n"
    " ```gleam\n"
    " let assert Ok(alphabet) =\n"
    "   sqid.alphabet(\"abcdefghijklmnopqrstuvwxyz\")\n"
    " ```\n"
    "\n"
    " ```gleam\n"
    " assert Error(Nil) == sqid.alphabet(\"wibble\")\n"
    "   as \"wrong alphabet: it contains duplicates\"\n"
    "\n"
    " assert Error(Nil) == sqid.alphabet(\"dziękuję\")\n"
    "   as \"wrong alphabet: it contains non ascii characters\"\n"
    "\n"
    " assert Error(Nil) == sqid.alphabet(\"01\")\n"
    "   as \"wrong alphabet: it contains less than 3 characters\"\n"
    " ```\n"
).
-spec alphabet(binary()) -> {ok, alphabet()} | {error, nil}.
alphabet(String) ->
    Letters = gleam@string:to_graphemes(String),
    gleam@bool:guard(
        has_duplicates(Letters),
        {error, nil},
        fun() ->
            gleam@bool:guard(
                gleam@list:any(Letters, fun is_multi_byte/1),
                {error, nil},
                fun() -> case Letters of
                        [] ->
                            {error, nil};

                        [_] ->
                            {error, nil};

                        [_, _] ->
                            {error, nil};

                        _ ->
                            Letters@1 = gleam@list:index_fold(
                                Letters,
                                maps:new(),
                                fun(Acc, Letter, Index) ->
                                    gleam@dict:insert(Acc, Index, Letter)
                                end
                            ),
                            {ok, shuffle_alphabet({alphabet, Letters@1})}
                    end end
            )
        end
    ).

-file("src/sqid.gleam", 124).
?DOC(
    " Creates an `Options` object from a valid alphabet.\n"
    " `Options` determine how Sqids are encoded and decoded.\n"
    "\n"
    " If you want to change the generated Sqids you can also use:\n"
    " - [`set_minimum_length`](#set_minimum_length): to pick a minimum length for\n"
    "   the generated Sqids.\n"
    " - [`set_blocklist`](#set_blocklist): to specify a blocklist of words that\n"
    "   will not end up in any of the generated Sqids.\n"
).
-spec new(alphabet()) -> options().
new(Alphabet) ->
    {options, Alphabet, 0, []}.

-file("src/sqid.gleam", 132).
?DOC(
    " Sets the minimum length of the generated Sqids.\n"
    " The value must be between 0 and 255. Any value lower than 0 is considered\n"
    " as 0, while any value higher than 255 is considered as 255.\n"
).
-spec set_minimum_length(options(), integer()) -> options().
set_minimum_length(Options, Minimum_length) ->
    {options,
        erlang:element(2, Options),
        gleam@int:clamp(Minimum_length, 0, 255),
        erlang:element(4, Options)}.

-file("src/sqid.gleam", 459).
-spec alphabet_to_string(alphabet()) -> binary().
alphabet_to_string(Alphabet) ->
    _pipe = maps:to_list(erlang:element(2, Alphabet)),
    _pipe@1 = gleam@list:sort(
        _pipe,
        fun(One, Other) ->
            gleam@int:compare(erlang:element(1, One), erlang:element(1, Other))
        end
    ),
    _pipe@2 = gleam@list:map(_pipe@1, fun(Pair) -> erlang:element(2, Pair) end),
    gleam@string:join(_pipe@2, <<""/utf8>>).

-file("src/sqid.gleam", 151).
?DOC(
    " Sets the list of blocked words that cannot appear inside any of the\n"
    " generated Sqids.\n"
    " This is useful if you want to make sure a generated Sqid cannot contain\n"
    " profanities.\n"
    "\n"
    " There's a couple of things to note:\n"
    " - The blocklist is case insensitive. If `\"gleam\"` is a blocked word,\n"
    "   generated Sqids will not contain any of `\"gLeaM\"`, `\"GLEAM\"`, `\"GLeam\"`,\n"
    "   ... and so on.\n"
    " - All words in the blocklist must be more than three characters long, any\n"
    "   word shorter than that will be ignored.\n"
).
-spec set_blocklist(options(), list(binary())) -> options().
set_blocklist(Options, Blocklist) ->
    Alphabet_string = alphabet_to_string(erlang:element(2, Options)),
    Blocklist@2 = gleam@list:fold(
        Blocklist,
        [],
        fun(Blocklist@1, Word) ->
            Word@1 = string:lowercase(Word),
            case gleam@string:to_graphemes(Word@1) of
                [] ->
                    Blocklist@1;

                [_] ->
                    Blocklist@1;

                [_, _] ->
                    Blocklist@1;

                Letters ->
                    case gleam@list:all(
                        Letters,
                        fun(_capture) ->
                            gleam_stdlib:contains_string(
                                Alphabet_string,
                                _capture
                            )
                        end
                    ) of
                        true ->
                            [Word@1 | Blocklist@1];

                        false ->
                            Blocklist@1
                    end
            end
        end
    ),
    {options,
        erlang:element(2, Options),
        erlang:element(3, Options),
        Blocklist@2}.

-file("src/sqid.gleam", 228).
?DOC(
    " Returns true if the id contains any of the words that are in the options'\n"
    " block list.\n"
    " Checking is case insensitive: if `\"gleam\"` is not allowed then `\"GLeaM\"`\n"
    " would be rejected as well.\n"
).
-spec is_blocked_id(binary(), options()) -> boolean().
is_blocked_id(Id, Options) ->
    Id@1 = string:lowercase(Id),
    Id_size = erlang:byte_size(Id@1),
    gleam@list:any(
        erlang:element(4, Options),
        fun(Blocked_word) ->
            Blocked_word_size = erlang:byte_size(Blocked_word),
            case Blocked_word_size > Id_size of
                true ->
                    false;

                false when (Id_size =< 3) orelse (Blocked_word_size =< 3) ->
                    Id@1 =:= Blocked_word;

                false ->
                    gleam_stdlib:contains_string(Id@1, Blocked_word)
            end
        end
    ).

-file("src/sqid.gleam", 310).
-spec pad_to_length_loop(binary(), integer(), alphabet()) -> binary().
pad_to_length_loop(Id, Missing, Alphabet) ->
    case Missing > 0 of
        false ->
            Id;

        true ->
            Alphabet@1 = shuffle_alphabet(Alphabet),
            Alphabet_size = maps:size(erlang:element(2, Alphabet@1)),
            Slice_size = gleam@int:min(Missing, Alphabet_size),
            Slice = gleam@string:slice(
                alphabet_to_string(Alphabet@1),
                0,
                Slice_size
            ),
            Id@1 = <<Id/binary, Slice/binary>>,
            Missing@1 = Missing - Slice_size,
            pad_to_length_loop(Id@1, Missing@1, Alphabet@1)
    end.

-file("src/sqid.gleam", 327).
?DOC(
    " Returns the separator of the alphabet, the separator changes based on how\n"
    " the\n"
).
-spec alphabet_separator(alphabet()) -> binary().
alphabet_separator(Alphabet) ->
    Separator@1 = case gleam_stdlib:map_get(erlang:element(2, Alphabet), 0) of
        {ok, Separator} -> Separator;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"empty alphabet"/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"sqid"/utf8>>,
                        function => <<"alphabet_separator"/utf8>>,
                        line => 328,
                        value => _assert_fail,
                        start => 11196,
                        'end' => 11252,
                        pattern_start => 11207,
                        pattern_end => 11220})
    end,
    Separator@1.

-file("src/sqid.gleam", 298).
-spec pad_to_length(binary(), integer(), alphabet()) -> binary().
pad_to_length(Id, Length, Alphabet) ->
    Id_length = erlang:byte_size(Id),
    case Id_length < Length of
        false ->
            Id;

        true ->
            Id@1 = <<Id/binary, (alphabet_separator(Alphabet))/binary>>,
            Missing = (Length - Id_length) - 1,
            pad_to_length_loop(Id@1, Missing, Alphabet)
    end.

-file("src/sqid.gleam", 271).
-spec number_to_id_loop(integer(), alphabet(), list(binary())) -> binary().
number_to_id_loop(Number, Alphabet, Acc) ->
    Alphabet_size = maps:size(erlang:element(2, Alphabet)) - 1,
    Letter@1 = case gleam_stdlib:map_get(
        erlang:element(2, Alphabet),
        (case Alphabet_size of
            0 -> 0;
            Gleam@denominator -> Number rem Gleam@denominator
        end) + 1
    ) of
        {ok, Letter} -> Letter;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"sqid"/utf8>>,
                        function => <<"number_to_id_loop"/utf8>>,
                        line => 281,
                        value => _assert_fail,
                        start => 9723,
                        'end' => 9809,
                        pattern_start => 9734,
                        pattern_end => 9744})
    end,
    Acc@1 = [Letter@1 | Acc],
    Number@1 = begin
        _pipe = math:floor(case erlang:float(Alphabet_size) of
                +0.0 -> +0.0;
                -0.0 -> -0.0;
                Gleam@denominator@1 -> erlang:float(Number) / Gleam@denominator@1
            end),
        erlang:round(_pipe)
    end,
    case Number@1 > 0 of
        true ->
            number_to_id_loop(Number@1, Alphabet, Acc@1);

        false ->
            gleam@string:join(Acc@1, <<""/utf8>>)
    end.

-file("src/sqid.gleam", 267).
-spec number_to_id(integer(), alphabet()) -> binary().
number_to_id(Number, Alphabet) ->
    number_to_id_loop(Number, Alphabet, []).

-file("src/sqid.gleam", 247).
-spec encode_numbers(list(integer()), alphabet(), binary()) -> {binary(),
    alphabet()}.
encode_numbers(Numbers, Alphabet, Id) ->
    case Numbers of
        [] ->
            {Id, Alphabet};

        [Last] ->
            {<<Id/binary, (number_to_id(Last, Alphabet))/binary>>, Alphabet};

        [First | Rest] ->
            Id@1 = <<Id/binary, (number_to_id(First, Alphabet))/binary>>,
            Id@2 = <<Id@1/binary, (alphabet_separator(Alphabet))/binary>>,
            Alphabet@1 = shuffle_alphabet(Alphabet),
            encode_numbers(Rest, Alphabet@1, Id@2)
    end.

-file("src/sqid.gleam", 449).
?DOC(
    " This reverses an alphabet: if the initial alphabet is \"abcd\", the reversed\n"
    " alphabet is going to be \"dcba\".\n"
).
-spec reverse_alphabet(alphabet()) -> alphabet().
reverse_alphabet(Alphabet) ->
    Size = maps:size(erlang:element(2, Alphabet)),
    Letters@1 = gleam@dict:fold(
        erlang:element(2, Alphabet),
        maps:new(),
        fun(Letters, Index, Letter) ->
            gleam@dict:insert(Letters, (Size - 1) - Index, Letter)
        end
    ),
    {alphabet, Letters@1}.

-file("src/sqid.gleam", 336).
?DOC(
    " Shifts the alphabet by the given offset.\n"
    " For example if alphabet is `\"abcde\"` and I end up shifting it by 2 to the\n"
    " left it ends up being `\"cdeab\"`.\n"
).
-spec shift_alphabet(alphabet(), integer()) -> alphabet().
shift_alphabet(Alphabet, Offset) ->
    Alphabet_size = maps:size(erlang:element(2, Alphabet)),
    Letters@1 = gleam@dict:fold(
        erlang:element(2, Alphabet),
        maps:new(),
        fun(Letters, Index, Letter) ->
            New_index = case Index < Offset of
                true ->
                    (Alphabet_size - Offset) + Index;

                false ->
                    Index - Offset
            end,
            gleam@dict:insert(Letters, New_index, Letter)
        end
    ),
    {alphabet, Letters@1}.

-file("src/sqid.gleam", 376).
?DOC(
    " This computes an offset from a list of numbers, the Sqid spec calls this\n"
    " \"semi random\": it's random looking but it's actually deterministically\n"
    " decided by the numbers and alphabet we pass as arguments.\n"
    " This returns an error if any of the numbers is negative.\n"
).
-spec semi_random_offset(alphabet(), list(integer())) -> {ok, integer()} |
    {error, nil}.
semi_random_offset(Alphabet, Numbers) ->
    Alphabet_size = maps:size(erlang:element(2, Alphabet)),
    _pipe = gleam@list:try_fold(
        Numbers,
        {erlang:length(Numbers), 0},
        fun(Pair, Number) ->
            {Acc, Index} = Pair,
            case Number < 0 of
                true ->
                    {error, nil};

                false ->
                    Letter_value@1 = case letter_value(
                        erlang:element(2, Alphabet),
                        case Alphabet_size of
                            0 -> 0;
                            Gleam@denominator -> Number rem Gleam@denominator
                        end
                    ) of
                        {ok, Letter_value} -> Letter_value;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"index outside of dictionary"/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"sqid"/utf8>>,
                                        function => <<"semi_random_offset"/utf8>>,
                                        line => 386,
                                        value => _assert_fail,
                                        start => 13405,
                                        'end' => 13499,
                                        pattern_start => 13416,
                                        pattern_end => 13432})
                    end,
                    {ok, {(Letter_value@1 + Index) + Acc, Index + 1}}
            end
        end
    ),
    gleam@result:map(_pipe, fun(Pair@1) -> erlang:element(1, Pair@1) end).

-file("src/sqid.gleam", 185).
-spec do_encode(options(), list(integer()), integer()) -> {ok, binary()} |
    {error, nil}.
do_encode(Options, Numbers, Attempts) ->
    case Attempts >= maps:size(erlang:element(2, erlang:element(2, Options))) of
        true ->
            {error, nil};

        false ->
            Alphabet_size = maps:size(
                erlang:element(2, erlang:element(2, Options))
            ),
            gleam@result:'try'(
                semi_random_offset(erlang:element(2, Options), Numbers),
                fun(Offset) ->
                    Offset@1 = case Alphabet_size of
                        0 -> 0;
                        Gleam@denominator -> Offset rem Gleam@denominator
                    end,
                    Offset@2 = case Alphabet_size of
                        0 -> 0;
                        Gleam@denominator@1 -> (Offset@1 + Attempts) rem Gleam@denominator@1
                    end,
                    Alphabet = shift_alphabet(
                        erlang:element(2, Options),
                        Offset@2
                    ),
                    Id = alphabet_separator(Alphabet),
                    Alphabet@1 = reverse_alphabet(Alphabet),
                    {Id@1, Alphabet@2} = encode_numbers(Numbers, Alphabet@1, Id),
                    Id@2 = pad_to_length(
                        Id@1,
                        erlang:element(3, Options),
                        Alphabet@2
                    ),
                    case is_blocked_id(Id@2, Options) of
                        true ->
                            do_encode(Options, Numbers, Attempts + 1);

                        false ->
                            {ok, Id@2}
                    end
                end
            )
    end.

-file("src/sqid.gleam", 178).
?DOC(
    " Encodes a list of numbers into a readable string using the given options.\n"
    " This function might fail if it's not possible to generate a string that is\n"
    " not excluded by the options' blocklist.\n"
).
-spec encode(options(), list(integer())) -> {ok, binary()} | {error, nil}.
encode(Options, Numbers) ->
    case Numbers of
        [] ->
            {ok, <<""/utf8>>};

        _ ->
            do_encode(Options, Numbers, 0)
    end.

-file("src/sqid.gleam", 528).
-spec index(binary(), binary()) -> {ok, integer()} | {error, nil}.
index(String, Separator) ->
    gleam@result:'try'(
        gleam@string:split_once(String, Separator),
        fun(_use0) ->
            {Before, _} = _use0,
            {ok, erlang:byte_size(Before)}
        end
    ).

-file("src/sqid.gleam", 518).
-spec id_to_number(binary(), alphabet()) -> {ok, integer()} | {error, nil}.
id_to_number(Id, Alphabet) ->
    Alphabet_size = maps:size(erlang:element(2, Alphabet)) - 1,
    Alphabet_string = alphabet_to_string(Alphabet),
    gleam@list:try_fold(
        gleam@string:to_graphemes(Id),
        0,
        fun(Acc, Letter) ->
            gleam@result:'try'(
                index(Alphabet_string, Letter),
                fun(Index) -> {ok, ((Acc * Alphabet_size) + Index) - 1} end
            )
        end
    ).

-file("src/sqid.gleam", 494).
-spec decode_loop(alphabet(), binary(), list(integer())) -> {ok,
        list(integer())} |
    {error, nil}.
decode_loop(Alphabet, Sqid, Numbers) ->
    Separator = alphabet_separator(Alphabet),
    case gleam@string:split(Sqid, Separator) of
        [] ->
            {ok, lists:reverse(Numbers)};

        [<<""/utf8>> | _] ->
            {ok, lists:reverse(Numbers)};

        [Id | Rest] ->
            case id_to_number(Id, Alphabet) of
                {error, _} ->
                    {error, nil};

                {ok, Number} ->
                    Numbers@1 = [Number | Numbers],
                    Alphabet@1 = shuffle_alphabet(Alphabet),
                    Sqid@1 = gleam@string:join(Rest, Separator),
                    decode_loop(Alphabet@1, Sqid@1, Numbers@1)
            end
    end.

-file("src/sqid.gleam", 475).
?DOC(
    " Decodes a Sqid into the list of integers that was used to generate it.\n"
    " To decode a Sqid, always use the same options that were used to encode it,\n"
    " otherwise you will get nonsense results!\n"
    "\n"
    " This function will fail if the Sqid has carachters that are not allowed by\n"
    " these options, meaning that the Sqid was encoded with a different alphabet.\n"
).
-spec decode(options(), binary()) -> {ok, list(integer())} | {error, nil}.
decode(Options, Sqid) ->
    case gleam_stdlib:string_pop_grapheme(Sqid) of
        {error, _} ->
            {ok, []};

        {ok, {Separator, Sqid@1}} ->
            case index(
                alphabet_to_string(erlang:element(2, Options)),
                Separator
            ) of
                {error, _} ->
                    {error, nil};

                {ok, Offset} ->
                    _pipe = shift_alphabet(erlang:element(2, Options), Offset),
                    _pipe@1 = reverse_alphabet(_pipe),
                    decode_loop(_pipe@1, Sqid@1, [])
            end
    end.