-module(packkit@internal@lzma).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/packkit/internal/lzma.gleam").
-export([new/3, properties_to_byte/1, properties_of_byte/1, decode_into/2, encode_literal_only/2, encode_with_lz77/2]).
-export_type([properties/0, decoder/0, encoder/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.
?MODULEDOC(false).
-type properties() :: {properties, integer(), integer(), integer()}.
-opaque decoder() :: {decoder,
integer(),
integer(),
bitstring(),
list(integer()),
integer(),
integer(),
integer(),
integer(),
integer(),
integer(),
integer(),
properties(),
gleam@dict:dict(integer(), integer())}.
-type encoder() :: {encoder,
integer(),
integer(),
integer(),
integer(),
integer(),
integer(),
integer(),
integer(),
integer(),
properties(),
gleam@dict:dict(integer(), integer()),
list(integer()),
integer(),
list(integer())}.
-file("src/packkit/internal/lzma.gleam", 326).
?DOC(false).
-spec previous_output_byte(decoder()) -> integer().
previous_output_byte(Decoder) ->
case erlang:element(5, Decoder) of
[Head | _] ->
Head;
[] ->
0
end.
-file("src/packkit/internal/lzma.gleam", 348).
?DOC(false).
-spec nth_back(list(integer()), integer()) -> {ok, integer()} | {error, nil}.
nth_back(Values, N) ->
case {Values, N} of
{[Head | _], 0} ->
{ok, Head};
{[_ | Rest], _} ->
nth_back(Rest, N - 1);
{[], _} ->
{error, nil}
end.
-file("src/packkit/internal/lzma.gleam", 337).
?DOC(false).
-spec byte_at_distance(decoder(), integer()) -> integer().
byte_at_distance(Decoder, Distance) ->
case Distance =< 0 of
true ->
0;
false ->
case nth_back(erlang:element(5, Decoder), Distance - 1) of
{ok, Value} ->
Value;
{error, _} ->
0
end
end.
-file("src/packkit/internal/lzma.gleam", 333).
?DOC(false).
-spec match_byte(decoder()) -> integer().
match_byte(Decoder) ->
byte_at_distance(Decoder, erlang:element(9, Decoder) + 1).
-file("src/packkit/internal/lzma.gleam", 356).
?DOC(false).
-spec advance_state_literal(decoder()) -> decoder().
advance_state_literal(Decoder) ->
New_state = case erlang:element(8, Decoder) of
0 ->
0;
1 ->
0;
2 ->
0;
3 ->
0;
4 ->
1;
5 ->
2;
6 ->
3;
7 ->
4;
8 ->
5;
9 ->
6;
10 ->
4;
_ ->
5
end,
{decoder,
erlang:element(2, Decoder),
erlang:element(3, Decoder),
erlang:element(4, Decoder),
erlang:element(5, Decoder),
erlang:element(6, Decoder),
erlang:element(7, Decoder),
New_state,
erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(11, Decoder),
erlang:element(12, Decoder),
erlang:element(13, Decoder),
erlang:element(14, Decoder)}.
-file("src/packkit/internal/lzma.gleam", 403).
?DOC(false).
-spec match_next(integer()) -> integer().
match_next(State) ->
case State < 7 of
true ->
7;
false ->
10
end.
-file("src/packkit/internal/lzma.gleam", 488).
?DOC(false).
-spec short_rep_next(integer()) -> integer().
short_rep_next(State) ->
case State < 7 of
true ->
9;
false ->
11
end.
-file("src/packkit/internal/lzma.gleam", 495).
?DOC(false).
-spec rep_next(integer()) -> integer().
rep_next(State) ->
case State < 7 of
true ->
8;
false ->
11
end.
-file("src/packkit/internal/lzma.gleam", 812).
?DOC(false).
-spec emit_byte(decoder(), integer()) -> decoder().
emit_byte(Decoder, Byte) ->
{decoder,
erlang:element(2, Decoder),
erlang:element(3, Decoder),
erlang:element(4, Decoder),
[Byte | erlang:element(5, Decoder)],
erlang:element(6, Decoder) + 1,
erlang:element(7, Decoder),
erlang:element(8, Decoder),
erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(11, Decoder),
erlang:element(12, Decoder),
erlang:element(13, Decoder),
erlang:element(14, Decoder)}.
-file("src/packkit/internal/lzma.gleam", 509).
?DOC(false).
-spec copy_loop(decoder(), integer(), integer()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
copy_loop(Decoder, Distance, Remaining) ->
case Remaining of
0 ->
{ok, Decoder};
_ ->
gleam@bool:guard(
(Distance >= erlang:element(6, Decoder)) andalso (erlang:element(
6,
Decoder
)
< erlang:element(7, Decoder)),
{error,
{codec_invalid_data,
<<"LZMA back-reference exceeds dictionary"/utf8>>}},
fun() ->
Byte = byte_at_distance(Decoder, Distance + 1),
Decoder@1 = emit_byte(Decoder, Byte),
copy_loop(Decoder@1, Distance, Remaining - 1)
end
)
end.
-file("src/packkit/internal/lzma.gleam", 502).
?DOC(false).
-spec apply_copy(decoder(), integer()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
apply_copy(Decoder, Length) ->
copy_loop(Decoder, erlang:element(9, Decoder), Length).
-file("src/packkit/internal/lzma.gleam", 820).
?DOC(false).
-spec prob_key(integer(), integer()) -> integer().
prob_key(Table, Sub_index) ->
(Table * 65536) + Sub_index.
-file("src/packkit/internal/lzma.gleam", 824).
?DOC(false).
-spec mask_for(integer()) -> integer().
mask_for(Bits) ->
erlang:'bsl'(1, Bits) - 1.
-file("src/packkit/internal/lzma.gleam", 828).
?DOC(false).
-spec read_u32_be(bitstring()) -> {ok, {integer(), bitstring()}} |
{error, packkit@error:codec_error()}.
read_u32_be(Bytes) ->
case Bytes of
<<Value:32/big-unsigned, Rest/binary>> ->
{ok, {Value, Rest}};
_ ->
{error,
{codec_invalid_data,
<<"LZMA range coder priming requires 4 bytes"/utf8>>}}
end.
-file("src/packkit/internal/lzma.gleam", 151).
?DOC(false).
-spec new(bitstring(), properties(), integer()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
new(Input, Props, Output_limit) ->
case Input of
<<First, Rest/binary>> ->
gleam@bool:guard(
First /= 0,
{error,
{codec_invalid_data,
<<"LZMA range coder must start with a zero byte"/utf8>>}},
fun() ->
gleam@result:'try'(
read_u32_be(Rest),
fun(_use0) ->
{Code, Rest@1} = _use0,
{ok,
{decoder,
16#FFFFFFFF,
Code,
Rest@1,
[],
0,
Output_limit,
0,
0,
0,
0,
0,
Props,
maps:new()}}
end
)
end
);
_ ->
{error,
{codec_invalid_data,
<<"LZMA range coder needs at least 5 priming bytes"/utf8>>}}
end.
-file("src/packkit/internal/lzma.gleam", 838).
?DOC(false).
-spec list_reverse_to_bit_array(list(integer()), bitstring()) -> bitstring().
list_reverse_to_bit_array(Values, Acc) ->
case Values of
[] ->
Acc;
[Head | Rest] ->
list_reverse_to_bit_array(Rest, <<Head, Acc/bitstring>>)
end.
-file("src/packkit/internal/lzma.gleam", 865).
?DOC(false).
-spec properties_to_byte(properties()) -> integer().
properties_to_byte(Props) ->
((erlang:element(4, Props) * 45) + (erlang:element(3, Props) * 9)) + erlang:element(
2,
Props
).
-file("src/packkit/internal/lzma.gleam", 986).
?DOC(false).
-spec literal_state_after(integer()) -> integer().
literal_state_after(State) ->
case State of
0 ->
0;
1 ->
0;
2 ->
0;
3 ->
0;
4 ->
1;
5 ->
2;
6 ->
3;
7 ->
4;
8 ->
5;
9 ->
6;
10 ->
4;
_ ->
5
end.
-file("src/packkit/internal/lzma.gleam", 1101).
?DOC(false).
-spec flush_cache_bytes(integer(), integer(), integer(), list(integer())) -> list(integer()).
flush_cache_bytes(Cache_byte, Cache_size, Carry, Out_rev) ->
case Cache_size of
0 ->
Out_rev;
_ ->
Byte = erlang:'band'(Cache_byte + Carry, 16#FF),
flush_cache_bytes(16#FF, Cache_size - 1, Carry, [Byte | Out_rev])
end.
-file("src/packkit/internal/lzma.gleam", 1239).
?DOC(false).
-spec byte_at_input(bitstring(), integer()) -> integer().
byte_at_input(Bytes, Pos) ->
case gleam_stdlib:bit_array_slice(Bytes, Pos, 1) of
{ok, <<B>>} ->
B;
_ ->
0
end.
-file("src/packkit/internal/lzma.gleam", 1246).
?DOC(false).
-spec lzma_hash3(integer(), integer(), integer()) -> integer().
lzma_hash3(B0, B1, B2) ->
erlang:'band'(
erlang:'bxor'(
erlang:'bxor'(B0 * 2654435761, B1 * 40503),
B2 * 2246822519
),
16#FFFF
).
-file("src/packkit/internal/lzma.gleam", 1258).
?DOC(false).
-spec lzma_match_length(bitstring(), integer(), integer(), integer(), integer()) -> integer().
lzma_match_length(Bytes, Prev, Cur, Cap, Acc) ->
case Acc >= Cap of
true ->
Acc;
false ->
case byte_at_input(Bytes, Prev + Acc) =:= byte_at_input(
Bytes,
Cur + Acc
) of
true ->
lzma_match_length(Bytes, Prev, Cur, Cap, Acc + 1);
false ->
Acc
end
end.
-file("src/packkit/internal/lzma.gleam", 1348).
?DOC(false).
-spec lzma_short_rep_next_state(integer()) -> integer().
lzma_short_rep_next_state(State) ->
case State < 7 of
true ->
9;
false ->
11
end.
-file("src/packkit/internal/lzma.gleam", 1478).
?DOC(false).
-spec which_rep_slot(encoder(), integer()) -> gleam@option:option(integer()).
which_rep_slot(Encoder, Distance_value) ->
case true of
_ when Distance_value =:= erlang:element(7, Encoder) ->
{some, 0};
_ when Distance_value =:= erlang:element(8, Encoder) ->
{some, 1};
_ when Distance_value =:= erlang:element(9, Encoder) ->
{some, 2};
_ when Distance_value =:= erlang:element(10, Encoder) ->
{some, 3};
_ ->
none
end.
-file("src/packkit/internal/lzma.gleam", 1582).
?DOC(false).
-spec lzma_rep_next_state(integer()) -> integer().
lzma_rep_next_state(State) ->
case State < 7 of
true ->
8;
false ->
11
end.
-file("src/packkit/internal/lzma.gleam", 1589).
?DOC(false).
-spec lzma_match_next_state(integer()) -> integer().
lzma_match_next_state(State) ->
case State < 7 of
true ->
7;
false ->
10
end.
-file("src/packkit/internal/lzma.gleam", 1709).
?DOC(false).
-spec high_bit_pos_loop(integer(), integer()) -> integer().
high_bit_pos_loop(Value, Pos) ->
case Value =< 1 of
true ->
Pos;
false ->
high_bit_pos_loop(erlang:'bsr'(Value, 1), Pos + 1)
end.
-file("src/packkit/internal/lzma.gleam", 1705).
?DOC(false).
-spec high_bit_pos(integer()) -> integer().
high_bit_pos(Value) ->
high_bit_pos_loop(Value, 0).
-file("src/packkit/internal/lzma.gleam", 1693).
?DOC(false).
-spec compute_pos_slot(integer()) -> integer().
compute_pos_slot(Distance) ->
case Distance < 4 of
true ->
Distance;
false ->
High_bit = high_bit_pos(Distance),
Next_bit = erlang:'band'(erlang:'bsr'(Distance, High_bit - 1), 1),
(High_bit * 2) + Next_bit
end.
-file("src/packkit/internal/lzma.gleam", 788).
?DOC(false).
-spec normalize(decoder()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
normalize(Decoder) ->
case erlang:element(2, Decoder) < 16777216 of
false ->
{ok, Decoder};
true ->
case erlang:element(4, Decoder) of
<<Byte, Rest/binary>> ->
{ok,
{decoder,
erlang:'band'(
erlang:element(2, Decoder) * 256,
16#FFFFFFFF
),
erlang:'band'(
(erlang:element(3, Decoder) * 256) + Byte,
16#FFFFFFFF
),
Rest,
erlang:element(5, Decoder),
erlang:element(6, Decoder),
erlang:element(7, Decoder),
erlang:element(8, Decoder),
erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(11, Decoder),
erlang:element(12, Decoder),
erlang:element(13, Decoder),
erlang:element(14, Decoder)}};
_ ->
{error,
{codec_invalid_data,
<<"LZMA range coder ran out of input bytes"/utf8>>}}
end
end.
-file("src/packkit/internal/lzma.gleam", 688).
?DOC(false).
-spec decode_direct_bits_loop(decoder(), integer(), integer()) -> {ok,
{integer(), decoder()}} |
{error, packkit@error:codec_error()}.
decode_direct_bits_loop(Decoder, Remaining, Acc) ->
case Remaining of
0 ->
{ok, {Acc, Decoder}};
_ ->
New_range = erlang:'bsr'(erlang:element(2, Decoder), 1),
case erlang:element(3, Decoder) >= New_range of
true ->
Decoder@1 = {decoder,
New_range,
erlang:element(3, Decoder) - New_range,
erlang:element(4, Decoder),
erlang:element(5, Decoder),
erlang:element(6, Decoder),
erlang:element(7, Decoder),
erlang:element(8, Decoder),
erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(11, Decoder),
erlang:element(12, Decoder),
erlang:element(13, Decoder),
erlang:element(14, Decoder)},
gleam@result:'try'(
normalize(Decoder@1),
fun(Decoder@2) ->
decode_direct_bits_loop(
Decoder@2,
Remaining - 1,
(Acc * 2) + 1
)
end
);
false ->
Decoder@3 = {decoder,
New_range,
erlang:element(3, Decoder),
erlang:element(4, Decoder),
erlang:element(5, Decoder),
erlang:element(6, Decoder),
erlang:element(7, Decoder),
erlang:element(8, Decoder),
erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(11, Decoder),
erlang:element(12, Decoder),
erlang:element(13, Decoder),
erlang:element(14, Decoder)},
gleam@result:'try'(
normalize(Decoder@3),
fun(Decoder@4) ->
decode_direct_bits_loop(
Decoder@4,
Remaining - 1,
Acc * 2
)
end
)
end
end.
-file("src/packkit/internal/lzma.gleam", 681).
?DOC(false).
-spec decode_direct_bits(decoder(), integer()) -> {ok, {integer(), decoder()}} |
{error, packkit@error:codec_error()}.
decode_direct_bits(Decoder, Count) ->
decode_direct_bits_loop(Decoder, Count, 0).
-file("src/packkit/internal/lzma.gleam", 643).
?DOC(false).
-spec decode_bit(decoder(), integer()) -> {ok, {integer(), decoder()}} |
{error, packkit@error:codec_error()}.
decode_bit(Decoder, Key) ->
Prob = case gleam_stdlib:map_get(erlang:element(14, Decoder), Key) of
{ok, Value} ->
Value;
{error, _} ->
1024
end,
Bound = erlang:'bsr'(erlang:element(2, Decoder), 11) * Prob,
case erlang:element(3, Decoder) < Bound of
true ->
New_prob = Prob + erlang:'bsr'(2048 - Prob, 5),
Decoder@1 = {decoder,
Bound,
erlang:element(3, Decoder),
erlang:element(4, Decoder),
erlang:element(5, Decoder),
erlang:element(6, Decoder),
erlang:element(7, Decoder),
erlang:element(8, Decoder),
erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(11, Decoder),
erlang:element(12, Decoder),
erlang:element(13, Decoder),
gleam@dict:insert(erlang:element(14, Decoder), Key, New_prob)},
gleam@result:'try'(
normalize(Decoder@1),
fun(Decoder@2) -> {ok, {0, Decoder@2}} end
);
false ->
New_prob@1 = Prob - erlang:'bsr'(Prob, 5),
Decoder@3 = {decoder,
erlang:element(2, Decoder) - Bound,
erlang:element(3, Decoder) - Bound,
erlang:element(4, Decoder),
erlang:element(5, Decoder),
erlang:element(6, Decoder),
erlang:element(7, Decoder),
erlang:element(8, Decoder),
erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(11, Decoder),
erlang:element(12, Decoder),
erlang:element(13, Decoder),
gleam@dict:insert(erlang:element(14, Decoder), Key, New_prob@1)},
gleam@result:'try'(
normalize(Decoder@3),
fun(Decoder@4) -> {ok, {1, Decoder@4}} end
)
end.
-file("src/packkit/internal/lzma.gleam", 723).
?DOC(false).
-spec decode_bit_tree_loop(
decoder(),
integer(),
integer(),
integer(),
integer(),
integer()
) -> {ok, {integer(), decoder()}} | {error, packkit@error:codec_error()}.
decode_bit_tree_loop(Decoder, Table, Base, Remaining, Symbol, Total_bits) ->
case Remaining of
0 ->
{ok, {Symbol - erlang:'bsl'(1, Total_bits), Decoder}};
_ ->
gleam@result:'try'(
decode_bit(Decoder, prob_key(Table, Base + Symbol)),
fun(_use0) ->
{Bit, Decoder@1} = _use0,
decode_bit_tree_loop(
Decoder@1,
Table,
Base,
Remaining - 1,
(Symbol * 2) + Bit,
Total_bits
)
end
)
end.
-file("src/packkit/internal/lzma.gleam", 714).
?DOC(false).
-spec decode_bit_tree(decoder(), integer(), integer(), integer()) -> {ok,
{integer(), decoder()}} |
{error, packkit@error:codec_error()}.
decode_bit_tree(Decoder, Table, Base, Num_bits) ->
decode_bit_tree_loop(Decoder, Table, Base, Num_bits, 1, Num_bits).
-file("src/packkit/internal/lzma.gleam", 759).
?DOC(false).
-spec decode_reverse_bit_tree_loop(
decoder(),
integer(),
integer(),
integer(),
integer(),
integer(),
integer()
) -> {ok, {integer(), decoder()}} | {error, packkit@error:codec_error()}.
decode_reverse_bit_tree_loop(
Decoder,
Table,
Base,
Remaining,
Symbol,
Result_acc,
Bit_index
) ->
case Remaining of
0 ->
{ok, {Result_acc, Decoder}};
_ ->
gleam@result:'try'(
decode_bit(Decoder, prob_key(Table, Base + Symbol)),
fun(_use0) ->
{Bit, Decoder@1} = _use0,
decode_reverse_bit_tree_loop(
Decoder@1,
Table,
Base,
Remaining - 1,
(Symbol * 2) + Bit,
Result_acc + erlang:'bsl'(Bit, Bit_index),
Bit_index + 1
)
end
)
end.
-file("src/packkit/internal/lzma.gleam", 750).
?DOC(false).
-spec decode_reverse_bit_tree(decoder(), integer(), integer(), integer()) -> {ok,
{integer(), decoder()}} |
{error, packkit@error:codec_error()}.
decode_reverse_bit_tree(Decoder, Table, Base, Num_bits) ->
decode_reverse_bit_tree_loop(Decoder, Table, Base, Num_bits, 1, 0, 0).
-file("src/packkit/internal/lzma.gleam", 106).
?DOC(false).
-spec properties_of_byte(integer()) -> {ok, properties()} |
{error, packkit@error:codec_error()}.
properties_of_byte(Byte) ->
gleam@bool:guard(
Byte > 224,
{error, {codec_invalid_data, <<"invalid LZMA properties byte"/utf8>>}},
fun() ->
Pb = Byte div 45,
Remainder = Byte - (Pb * 45),
Lp = Remainder div 9,
Lc = Remainder - (Lp * 9),
gleam@bool:guard(
(Lc + Lp) > 4,
{error,
{codec_invalid_data, <<"LZMA lc + lp must be <= 4"/utf8>>}},
fun() ->
gleam@bool:guard(
Pb > 4,
{error,
{codec_invalid_data,
<<"LZMA pb out of range"/utf8>>}},
fun() -> {ok, {properties, Lc, Lp, Pb}} end
)
end
)
end
).
-file("src/packkit/internal/lzma.gleam", 533).
?DOC(false).
-spec decode_length(
decoder(),
integer(),
integer(),
integer(),
integer(),
integer(),
integer()
) -> {ok, {integer(), decoder()}} | {error, packkit@error:codec_error()}.
decode_length(Decoder, Pos_state, T_choice, T_choice2, T_low, T_mid, T_high) ->
gleam@result:'try'(
decode_bit(Decoder, prob_key(T_choice, 0)),
fun(_use0) ->
{Choice, Decoder@1} = _use0,
case Choice of
0 ->
gleam@result:'try'(
decode_bit_tree(Decoder@1, T_low, Pos_state * 8, 3),
fun(_use0@1) ->
{Value, Decoder@2} = _use0@1,
{ok, {2 + Value, Decoder@2}}
end
);
_ ->
gleam@result:'try'(
decode_bit(Decoder@1, prob_key(T_choice2, 0)),
fun(_use0@2) ->
{Choice2, Decoder@3} = _use0@2,
case Choice2 of
0 ->
gleam@result:'try'(
decode_bit_tree(
Decoder@3,
T_mid,
Pos_state * 8,
3
),
fun(_use0@3) ->
{Value@1, Decoder@4} = _use0@3,
{ok, {(2 + 8) + Value@1, Decoder@4}}
end
);
_ ->
gleam@result:'try'(
decode_bit_tree(Decoder@3, T_high, 0, 8),
fun(_use0@4) ->
{Value@2, Decoder@5} = _use0@4,
{ok,
{((2 + 8) + 8) + Value@2,
Decoder@5}}
end
)
end
end
)
end
end
).
-file("src/packkit/internal/lzma.gleam", 271).
?DOC(false).
-spec decode_literal_normal(decoder(), integer(), integer()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
decode_literal_normal(Decoder, Base, Symbol) ->
case Symbol >= 16#100 of
true ->
Byte = erlang:'band'(Symbol, 16#FF),
Decoder@1 = emit_byte(Decoder, Byte),
{ok, advance_state_literal(Decoder@1)};
false ->
gleam@result:'try'(
decode_bit(Decoder, prob_key(6, Base + Symbol)),
fun(_use0) ->
{Bit, Decoder@2} = _use0,
decode_literal_normal(Decoder@2, Base, (Symbol * 2) + Bit)
end
)
end.
-file("src/packkit/internal/lzma.gleam", 292).
?DOC(false).
-spec decode_literal_matched(decoder(), integer(), integer(), integer()) -> {ok,
decoder()} |
{error, packkit@error:codec_error()}.
decode_literal_matched(Decoder, Base, Symbol, Match_b) ->
case Symbol >= 16#100 of
true ->
Byte = erlang:'band'(Symbol, 16#FF),
Decoder@1 = emit_byte(Decoder, Byte),
{ok, advance_state_literal(Decoder@1)};
false ->
Match_bit = erlang:'band'(erlang:'bsr'(Match_b, 7), 16#01),
Next_match = erlang:'band'(Match_b * 2, 16#FF),
Prob_offset = (16#100 + (Match_bit * 16#100)) + Symbol,
gleam@result:'try'(
decode_bit(Decoder, prob_key(6, Base + Prob_offset)),
fun(_use0) ->
{Bit, Decoder@2} = _use0,
case Bit =:= Match_bit of
true ->
decode_literal_matched(
Decoder@2,
Base,
(Symbol * 2) + Bit,
Next_match
);
false ->
decode_literal_normal(
Decoder@2,
Base,
(Symbol * 2) + Bit
)
end
end
)
end.
-file("src/packkit/internal/lzma.gleam", 254).
?DOC(false).
-spec decode_literal(decoder()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
decode_literal(Decoder) ->
Prev_byte = previous_output_byte(Decoder),
Lit_pos_state = erlang:'band'(
erlang:element(6, Decoder),
mask_for(erlang:element(3, erlang:element(13, Decoder)))
),
Lit_high = erlang:'bsr'(
Prev_byte,
8 - erlang:element(2, erlang:element(13, Decoder))
),
Context_index = erlang:'bor'(
erlang:'bsl'(
Lit_pos_state,
erlang:element(2, erlang:element(13, Decoder))
),
Lit_high
),
Prob_base = Context_index * 16#300,
case erlang:element(8, Decoder) < 7 of
true ->
decode_literal_normal(Decoder, Prob_base, 1);
false ->
decode_literal_matched(Decoder, Prob_base, 1, match_byte(Decoder))
end.
-file("src/packkit/internal/lzma.gleam", 587).
?DOC(false).
-spec decode_distance(decoder(), integer()) -> {ok, {integer(), decoder()}} |
{error, packkit@error:codec_error()}.
decode_distance(Decoder, Length) ->
Len_state = case (Length - 2) < 4 of
true ->
Length - 2;
false ->
4 - 1
end,
gleam@result:'try'(
decode_bit_tree(Decoder, 7, Len_state * 64, 6),
fun(_use0) ->
{Pos_slot, Decoder@1} = _use0,
case Pos_slot < 4 of
true ->
{ok, {Pos_slot, Decoder@1}};
false ->
Num_direct_bits = erlang:'bsr'(Pos_slot, 1) - 1,
Base = erlang:'bsl'(
erlang:'bor'(2, erlang:'band'(Pos_slot, 1)),
Num_direct_bits
),
case Pos_slot < 14 of
true ->
Offset = Base - Pos_slot,
gleam@result:'try'(
decode_reverse_bit_tree(
Decoder@1,
8,
Offset,
Num_direct_bits
),
fun(_use0@1) ->
{Extra, Decoder@2} = _use0@1,
{ok, {Base + Extra, Decoder@2}}
end
);
false ->
High_bits = Num_direct_bits - 4,
gleam@result:'try'(
decode_direct_bits(Decoder@1, High_bits),
fun(_use0@2) ->
{Top, Decoder@3} = _use0@2,
Middle = erlang:'bsl'(Top, 4),
gleam@result:'try'(
decode_reverse_bit_tree(
Decoder@3,
9,
0,
4
),
fun(_use0@3) ->
{Align_bits, Decoder@4} = _use0@3,
{ok,
{(Base + Middle) + Align_bits,
Decoder@4}}
end
)
end
)
end
end
end
).
-file("src/packkit/internal/lzma.gleam", 376).
?DOC(false).
-spec decode_match(decoder(), integer()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
decode_match(Decoder, Pos_state) ->
_ = Pos_state,
Decoder@1 = {decoder,
erlang:element(2, Decoder),
erlang:element(3, Decoder),
erlang:element(4, Decoder),
erlang:element(5, Decoder),
erlang:element(6, Decoder),
erlang:element(7, Decoder),
erlang:element(8, Decoder),
erlang:element(9, Decoder),
erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(11, Decoder),
erlang:element(13, Decoder),
erlang:element(14, Decoder)},
gleam@result:'try'(
decode_length(Decoder@1, Pos_state, 10, 11, 12, 13, 14),
fun(_use0) ->
{Length, Decoder@2} = _use0,
gleam@result:'try'(
decode_distance(Decoder@2, Length),
fun(_use0@1) ->
{Distance, Decoder@3} = _use0@1,
Decoder@4 = {decoder,
erlang:element(2, Decoder@3),
erlang:element(3, Decoder@3),
erlang:element(4, Decoder@3),
erlang:element(5, Decoder@3),
erlang:element(6, Decoder@3),
erlang:element(7, Decoder@3),
match_next(erlang:element(8, Decoder@3)),
Distance,
erlang:element(10, Decoder@3),
erlang:element(11, Decoder@3),
erlang:element(12, Decoder@3),
erlang:element(13, Decoder@3),
erlang:element(14, Decoder@3)},
apply_copy(Decoder@4, Length)
end
)
end
).
-file("src/packkit/internal/lzma.gleam", 456).
?DOC(false).
-spec apply_rep_match(decoder(), integer(), integer()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
apply_rep_match(Decoder, Selected, Pos_state) ->
{Rep1, Rep2, Rep3} = case true of
_ when Selected =:= erlang:element(9, Decoder) ->
{erlang:element(10, Decoder),
erlang:element(11, Decoder),
erlang:element(12, Decoder)};
_ when Selected =:= erlang:element(10, Decoder) ->
{erlang:element(9, Decoder),
erlang:element(11, Decoder),
erlang:element(12, Decoder)};
_ when Selected =:= erlang:element(11, Decoder) ->
{erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(12, Decoder)};
_ ->
{erlang:element(9, Decoder),
erlang:element(10, Decoder),
erlang:element(11, Decoder)}
end,
Decoder@1 = {decoder,
erlang:element(2, Decoder),
erlang:element(3, Decoder),
erlang:element(4, Decoder),
erlang:element(5, Decoder),
erlang:element(6, Decoder),
erlang:element(7, Decoder),
rep_next(erlang:element(8, Decoder)),
Selected,
Rep1,
Rep2,
Rep3,
erlang:element(13, Decoder),
erlang:element(14, Decoder)},
gleam@result:'try'(
decode_length(Decoder@1, Pos_state, 15, 16, 17, 18, 19),
fun(_use0) ->
{Length, Decoder@2} = _use0,
apply_copy(Decoder@2, Length)
end
).
-file("src/packkit/internal/lzma.gleam", 412).
?DOC(false).
-spec decode_rep(decoder(), integer()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
decode_rep(Decoder, Pos_state) ->
gleam@result:'try'(
decode_bit(Decoder, prob_key(2, erlang:element(8, Decoder))),
fun(_use0) ->
{G0, Decoder@1} = _use0,
case G0 of
0 ->
gleam@result:'try'(
decode_bit(
Decoder@1,
prob_key(
5,
(erlang:element(8, Decoder@1) * 16) + Pos_state
)
),
fun(_use0@1) ->
{G0_long, Decoder@2} = _use0@1,
case G0_long of
0 ->
Decoder@3 = {decoder,
erlang:element(2, Decoder@2),
erlang:element(3, Decoder@2),
erlang:element(4, Decoder@2),
erlang:element(5, Decoder@2),
erlang:element(6, Decoder@2),
erlang:element(7, Decoder@2),
short_rep_next(
erlang:element(8, Decoder@2)
),
erlang:element(9, Decoder@2),
erlang:element(10, Decoder@2),
erlang:element(11, Decoder@2),
erlang:element(12, Decoder@2),
erlang:element(13, Decoder@2),
erlang:element(14, Decoder@2)},
apply_copy(Decoder@3, 1);
_ ->
apply_rep_match(
Decoder@2,
erlang:element(9, Decoder@2),
Pos_state
)
end
end
);
_ ->
gleam@result:'try'(
decode_bit(
Decoder@1,
prob_key(3, erlang:element(8, Decoder@1))
),
fun(_use0@2) ->
{G1, Decoder@4} = _use0@2,
case G1 of
0 ->
apply_rep_match(
Decoder@4,
erlang:element(10, Decoder@4),
Pos_state
);
_ ->
gleam@result:'try'(
decode_bit(
Decoder@4,
prob_key(
4,
erlang:element(8, Decoder@4)
)
),
fun(_use0@3) ->
{G2, Decoder@5} = _use0@3,
case G2 of
0 ->
apply_rep_match(
Decoder@5,
erlang:element(
11,
Decoder@5
),
Pos_state
);
_ ->
apply_rep_match(
Decoder@5,
erlang:element(
12,
Decoder@5
),
Pos_state
)
end
end
)
end
end
)
end
end
).
-file("src/packkit/internal/lzma.gleam", 212).
?DOC(false).
-spec loop_until(decoder(), integer()) -> {ok, decoder()} |
{error, packkit@error:codec_error()}.
loop_until(Decoder, Desired_output) ->
case erlang:element(6, Decoder) >= Desired_output of
true ->
{ok, Decoder};
false ->
Pos_state = erlang:'band'(
erlang:element(6, Decoder),
mask_for(erlang:element(4, erlang:element(13, Decoder)))
),
case decode_bit(
Decoder,
prob_key(0, (erlang:element(8, Decoder) * 16) + Pos_state)
) of
{error, E} ->
{error, E};
{ok, {0, Decoder@1}} ->
case decode_literal(Decoder@1) of
{error, E@1} ->
{error, E@1};
{ok, Decoder@2} ->
loop_until(Decoder@2, Desired_output)
end;
{ok, {_, Decoder@3}} ->
case decode_bit(
Decoder@3,
prob_key(1, erlang:element(8, Decoder@3))
) of
{error, E@2} ->
{error, E@2};
{ok, {0, Decoder@4}} ->
case decode_match(Decoder@4, Pos_state) of
{error, E@3} ->
{error, E@3};
{ok, Decoder@5} ->
loop_until(Decoder@5, Desired_output)
end;
{ok, {_, Decoder@6}} ->
case decode_rep(Decoder@6, Pos_state) of
{error, E@4} ->
{error, E@4};
{ok, Decoder@7} ->
loop_until(Decoder@7, Desired_output)
end
end
end
end.
-file("src/packkit/internal/lzma.gleam", 191).
?DOC(false).
-spec decode_into(decoder(), integer()) -> {ok, {bitstring(), decoder()}} |
{error, packkit@error:codec_error()}.
decode_into(Decoder, Desired_output) ->
gleam@result:'try'(
loop_until(Decoder, Desired_output),
fun(Decoder@1) ->
Bytes = list_reverse_to_bit_array(
erlang:element(5, Decoder@1),
<<>>
),
{ok, {Bytes, Decoder@1}}
end
).
-file("src/packkit/internal/lzma.gleam", 904).
?DOC(false).
-spec new_encoder(properties()) -> encoder().
new_encoder(Props) ->
{encoder, 16#FFFFFFFF, 0, 0, 1, 0, 0, 0, 0, 0, Props, maps:new(), [], 0, []}.
-file("src/packkit/internal/lzma.gleam", 1083).
?DOC(false).
-spec shift_low_left_byte(integer()) -> integer().
shift_low_left_byte(Low) ->
Truncated = case Low >= 4294967296 of
true ->
Low - (4294967296 * (case 4294967296 of
0 -> 0;
Gleam@denominator -> Low div Gleam@denominator
end));
false ->
Low
end,
Raw = Truncated * 256,
case Raw >= 4294967296 of
true ->
Raw - (4294967296 * (case 4294967296 of
0 -> 0;
Gleam@denominator@1 -> Raw div Gleam@denominator@1
end));
false ->
Raw
end.
-file("src/packkit/internal/lzma.gleam", 1049).
?DOC(false).
-spec shift_low_encoder(encoder()) -> encoder().
shift_low_encoder(Encoder) ->
case (erlang:element(3, Encoder) < 16#FF000000) orelse (erlang:element(
3,
Encoder
)
> 16#FFFFFFFF) of
true ->
Carry = case 4294967296 of
0 -> 0;
Gleam@denominator -> erlang:element(3, Encoder) div Gleam@denominator
end,
Flushed = flush_cache_bytes(
erlang:element(4, Encoder),
erlang:element(5, Encoder),
Carry,
erlang:element(15, Encoder)
),
New_cache = erlang:'band'(
erlang:element(3, Encoder) div 16777216,
16#FF
),
New_low = shift_low_left_byte(erlang:element(3, Encoder)),
{encoder,
erlang:element(2, Encoder),
New_low,
New_cache,
1,
erlang:element(6, Encoder),
erlang:element(7, Encoder),
erlang:element(8, Encoder),
erlang:element(9, Encoder),
erlang:element(10, Encoder),
erlang:element(11, Encoder),
erlang:element(12, Encoder),
erlang:element(13, Encoder),
erlang:element(14, Encoder),
Flushed};
false ->
New_low@1 = shift_low_left_byte(erlang:element(3, Encoder)),
{encoder,
erlang:element(2, Encoder),
New_low@1,
erlang:element(4, Encoder),
erlang:element(5, Encoder) + 1,
erlang:element(6, Encoder),
erlang:element(7, Encoder),
erlang:element(8, Encoder),
erlang:element(9, Encoder),
erlang:element(10, Encoder),
erlang:element(11, Encoder),
erlang:element(12, Encoder),
erlang:element(13, Encoder),
erlang:element(14, Encoder),
erlang:element(15, Encoder)}
end.
-file("src/packkit/internal/lzma.gleam", 1033).
?DOC(false).
-spec normalize_encoder(encoder()) -> encoder().
normalize_encoder(Encoder) ->
case erlang:element(2, Encoder) < 16777216 of
false ->
Encoder;
true ->
Encoder@1 = shift_low_encoder(Encoder),
Encoder@2 = {encoder,
erlang:element(2, Encoder@1) * 256,
erlang:element(3, Encoder@1),
erlang:element(4, Encoder@1),
erlang:element(5, Encoder@1),
erlang:element(6, Encoder@1),
erlang:element(7, Encoder@1),
erlang:element(8, Encoder@1),
erlang:element(9, Encoder@1),
erlang:element(10, Encoder@1),
erlang:element(11, Encoder@1),
erlang:element(12, Encoder@1),
erlang:element(13, Encoder@1),
erlang:element(14, Encoder@1),
erlang:element(15, Encoder@1)},
normalize_encoder(Encoder@2)
end.
-file("src/packkit/internal/lzma.gleam", 1003).
?DOC(false).
-spec encode_bit(encoder(), integer(), integer()) -> encoder().
encode_bit(Encoder, Key, Bit) ->
Prob = case gleam_stdlib:map_get(erlang:element(12, Encoder), Key) of
{ok, Value} ->
Value;
{error, _} ->
1024
end,
New_bound = erlang:'bsr'(erlang:element(2, Encoder), 11) * Prob,
Encoder@1 = case Bit of
0 ->
New_prob = Prob + erlang:'bsr'(2048 - Prob, 5),
{encoder,
New_bound,
erlang:element(3, Encoder),
erlang:element(4, Encoder),
erlang:element(5, Encoder),
erlang:element(6, Encoder),
erlang:element(7, Encoder),
erlang:element(8, Encoder),
erlang:element(9, Encoder),
erlang:element(10, Encoder),
erlang:element(11, Encoder),
gleam@dict:insert(erlang:element(12, Encoder), Key, New_prob),
erlang:element(13, Encoder),
erlang:element(14, Encoder),
erlang:element(15, Encoder)};
_ ->
New_prob@1 = Prob - erlang:'bsr'(Prob, 5),
{encoder,
erlang:element(2, Encoder) - New_bound,
erlang:element(3, Encoder) + New_bound,
erlang:element(4, Encoder),
erlang:element(5, Encoder),
erlang:element(6, Encoder),
erlang:element(7, Encoder),
erlang:element(8, Encoder),
erlang:element(9, Encoder),
erlang:element(10, Encoder),
erlang:element(11, Encoder),
gleam@dict:insert(erlang:element(12, Encoder), Key, New_prob@1),
erlang:element(13, Encoder),
erlang:element(14, Encoder),
erlang:element(15, Encoder)}
end,
normalize_encoder(Encoder@1).
-file("src/packkit/internal/lzma.gleam", 968).
?DOC(false).
-spec encode_literal_bits(encoder(), integer(), integer(), integer(), integer()) -> encoder().
encode_literal_bits(Encoder, Base, Symbol, Byte, Remaining) ->
case Remaining of
0 ->
Encoder;
_ ->
Bit_pos = Remaining - 1,
Bit = erlang:'band'(erlang:'bsr'(Byte, Bit_pos), 1),
Encoder@1 = encode_bit(Encoder, prob_key(6, Base + Symbol), Bit),
encode_literal_bits(
Encoder@1,
Base,
(Symbol * 2) + Bit,
Byte,
Remaining - 1
)
end.
-file("src/packkit/internal/lzma.gleam", 948).
?DOC(false).
-spec encode_literal_byte(encoder(), integer()) -> encoder().
encode_literal_byte(Encoder, Byte) ->
Prev_byte = case erlang:element(13, Encoder) of
[Head | _] ->
Head;
[] ->
0
end,
Lit_pos_state = erlang:'band'(
erlang:element(14, Encoder),
mask_for(erlang:element(3, erlang:element(11, Encoder)))
),
Lit_high = erlang:'bsr'(
Prev_byte,
8 - erlang:element(2, erlang:element(11, Encoder))
),
Context_index = erlang:'bor'(
erlang:'bsl'(
Lit_pos_state,
erlang:element(2, erlang:element(11, Encoder))
),
Lit_high
),
Prob_base = Context_index * 16#300,
Encoder@1 = encode_literal_bits(Encoder, Prob_base, 1, Byte, 8),
{encoder,
erlang:element(2, Encoder@1),
erlang:element(3, Encoder@1),
erlang:element(4, Encoder@1),
erlang:element(5, Encoder@1),
literal_state_after(erlang:element(6, Encoder@1)),
erlang:element(7, Encoder@1),
erlang:element(8, Encoder@1),
erlang:element(9, Encoder@1),
erlang:element(10, Encoder@1),
erlang:element(11, Encoder@1),
erlang:element(12, Encoder@1),
erlang:element(13, Encoder@1),
erlang:element(14, Encoder@1),
erlang:element(15, Encoder@1)}.
-file("src/packkit/internal/lzma.gleam", 923).
?DOC(false).
-spec encode_literal_only_loop(encoder(), bitstring()) -> encoder().
encode_literal_only_loop(Encoder, Input) ->
case Input of
<<Byte, Rest/binary>> ->
Pos_state = erlang:'band'(
erlang:element(14, Encoder),
mask_for(erlang:element(4, erlang:element(11, Encoder)))
),
Encoder@1 = encode_bit(
Encoder,
prob_key(0, (erlang:element(6, Encoder) * 16) + Pos_state),
0
),
Encoder@2 = encode_literal_byte(Encoder@1, Byte),
Encoder@3 = {encoder,
erlang:element(2, Encoder@2),
erlang:element(3, Encoder@2),
erlang:element(4, Encoder@2),
erlang:element(5, Encoder@2),
erlang:element(6, Encoder@2),
erlang:element(7, Encoder@2),
erlang:element(8, Encoder@2),
erlang:element(9, Encoder@2),
erlang:element(10, Encoder@2),
erlang:element(11, Encoder@2),
erlang:element(12, Encoder@2),
[Byte | erlang:element(13, Encoder@2)],
erlang:element(14, Encoder@2) + 1,
erlang:element(15, Encoder@2)},
encode_literal_only_loop(Encoder@3, Rest);
_ ->
Encoder
end.
-file("src/packkit/internal/lzma.gleam", 1116).
?DOC(false).
-spec finish_encoder(encoder()) -> encoder().
finish_encoder(Encoder) ->
_pipe = Encoder,
_pipe@1 = shift_low_encoder(_pipe),
_pipe@2 = shift_low_encoder(_pipe@1),
_pipe@3 = shift_low_encoder(_pipe@2),
_pipe@4 = shift_low_encoder(_pipe@3),
shift_low_encoder(_pipe@4).
-file("src/packkit/internal/lzma.gleam", 875).
?DOC(false).
-spec encode_literal_only(bitstring(), properties()) -> bitstring().
encode_literal_only(Bytes, Props) ->
Encoder = new_encoder(Props),
Encoder@1 = encode_literal_only_loop(Encoder, Bytes),
Encoder@2 = finish_encoder(Encoder@1),
list_reverse_to_bit_array(erlang:element(15, Encoder@2), <<>>).
-file("src/packkit/internal/lzma.gleam", 1326).
?DOC(false).
-spec emit_lzma_short_rep(encoder(), integer()) -> encoder().
emit_lzma_short_rep(Encoder, Pos_state) ->
Encoder@1 = encode_bit(
Encoder,
prob_key(0, (erlang:element(6, Encoder) * 16) + Pos_state),
1
),
Encoder@2 = encode_bit(
Encoder@1,
prob_key(1, erlang:element(6, Encoder@1)),
1
),
Encoder@3 = encode_bit(
Encoder@2,
prob_key(2, erlang:element(6, Encoder@2)),
0
),
Encoder@4 = encode_bit(
Encoder@3,
prob_key(5, (erlang:element(6, Encoder@3) * 16) + Pos_state),
0
),
{encoder,
erlang:element(2, Encoder@4),
erlang:element(3, Encoder@4),
erlang:element(4, Encoder@4),
erlang:element(5, Encoder@4),
lzma_short_rep_next_state(erlang:element(6, Encoder@4)),
erlang:element(7, Encoder@4),
erlang:element(8, Encoder@4),
erlang:element(9, Encoder@4),
erlang:element(10, Encoder@4),
erlang:element(11, Encoder@4),
erlang:element(12, Encoder@4),
erlang:element(13, Encoder@4),
erlang:element(14, Encoder@4) + 1,
erlang:element(15, Encoder@4)}.
-file("src/packkit/internal/lzma.gleam", 1405).
?DOC(false).
-spec encode_matched_literal_bits(
encoder(),
integer(),
integer(),
integer(),
integer(),
boolean(),
integer()
) -> encoder().
encode_matched_literal_bits(
Encoder,
Base,
Symbol,
Byte,
Match_byte,
Matched,
Remaining
) ->
case Remaining of
0 ->
Encoder;
_ ->
Bit_pos = Remaining - 1,
Bit = erlang:'band'(erlang:'bsr'(Byte, Bit_pos), 1),
case Matched of
true ->
Match_bit = erlang:'band'(
erlang:'bsr'(Match_byte, Bit_pos),
1
),
Prob_offset = (16#100 + (Match_bit * 16#100)) + Symbol,
Encoder@1 = encode_bit(
Encoder,
prob_key(6, Base + Prob_offset),
Bit
),
encode_matched_literal_bits(
Encoder@1,
Base,
(Symbol * 2) + Bit,
Byte,
Match_byte,
Bit =:= Match_bit,
Remaining - 1
);
false ->
Encoder@2 = encode_bit(
Encoder,
prob_key(6, Base + Symbol),
Bit
),
encode_matched_literal_bits(
Encoder@2,
Base,
(Symbol * 2) + Bit,
Byte,
Match_byte,
false,
Remaining - 1
)
end
end.
-file("src/packkit/internal/lzma.gleam", 1355).
?DOC(false).
-spec emit_lzma_literal(encoder(), bitstring(), integer(), integer()) -> encoder().
emit_lzma_literal(Encoder, Bytes, Pos, Byte) ->
Pos_state = erlang:'band'(
Pos,
mask_for(erlang:element(4, erlang:element(11, Encoder)))
),
Encoder@1 = encode_bit(
Encoder,
prob_key(0, (erlang:element(6, Encoder) * 16) + Pos_state),
0
),
Prev_byte = case Pos of
0 ->
0;
_ ->
byte_at_input(Bytes, Pos - 1)
end,
Lit_pos_state = erlang:'band'(
Pos,
mask_for(erlang:element(3, erlang:element(11, Encoder@1)))
),
Lit_high = erlang:'bsr'(
Prev_byte,
8 - erlang:element(2, erlang:element(11, Encoder@1))
),
Context_index = erlang:'bor'(
erlang:'bsl'(
Lit_pos_state,
erlang:element(2, erlang:element(11, Encoder@1))
),
Lit_high
),
Prob_base = Context_index * 16#300,
Encoder@2 = case erlang:element(6, Encoder@1) < 7 of
true ->
encode_literal_bits(Encoder@1, Prob_base, 1, Byte, 8);
false ->
Match_byte = byte_at_input(
Bytes,
(Pos - erlang:element(7, Encoder@1)) - 1
),
encode_matched_literal_bits(
Encoder@1,
Prob_base,
1,
Byte,
Match_byte,
true,
8
)
end,
{encoder,
erlang:element(2, Encoder@2),
erlang:element(3, Encoder@2),
erlang:element(4, Encoder@2),
erlang:element(5, Encoder@2),
literal_state_after(erlang:element(6, Encoder@2)),
erlang:element(7, Encoder@2),
erlang:element(8, Encoder@2),
erlang:element(9, Encoder@2),
erlang:element(10, Encoder@2),
erlang:element(11, Encoder@2),
erlang:element(12, Encoder@2),
erlang:element(13, Encoder@2),
erlang:element(14, Encoder@2) + 1,
erlang:element(15, Encoder@2)}.
-file("src/packkit/internal/lzma.gleam", 1310).
?DOC(false).
-spec emit_lzma_literal_or_short_rep(
encoder(),
bitstring(),
integer(),
integer()
) -> encoder().
emit_lzma_literal_or_short_rep(Encoder, Bytes, Pos, Byte) ->
Back = (Pos - erlang:element(7, Encoder)) - 1,
case (Back >= 0) andalso (byte_at_input(Bytes, Back) =:= Byte) of
true ->
Pos_state = erlang:'band'(
Pos,
mask_for(erlang:element(4, erlang:element(11, Encoder)))
),
emit_lzma_short_rep(Encoder, Pos_state);
false ->
emit_lzma_literal(Encoder, Bytes, Pos, Byte)
end.
-file("src/packkit/internal/lzma.gleam", 1726).
?DOC(false).
-spec encode_bit_tree_loop(
encoder(),
integer(),
integer(),
integer(),
integer(),
integer()
) -> encoder().
encode_bit_tree_loop(Encoder, Table, Base, Remaining, Context, Value) ->
case Remaining of
0 ->
Encoder;
_ ->
Bit_pos = Remaining - 1,
Bit = erlang:'band'(erlang:'bsr'(Value, Bit_pos), 1),
Encoder@1 = encode_bit(
Encoder,
prob_key(Table, Base + Context),
Bit
),
encode_bit_tree_loop(
Encoder@1,
Table,
Base,
Remaining - 1,
(Context * 2) + Bit,
Value
)
end.
-file("src/packkit/internal/lzma.gleam", 1716).
?DOC(false).
-spec encode_bit_tree(encoder(), integer(), integer(), integer(), integer()) -> encoder().
encode_bit_tree(Encoder, Table, Base, Num_bits, Value) ->
encode_bit_tree_loop(Encoder, Table, Base, Num_bits, 1, Value).
-file("src/packkit/internal/lzma.gleam", 1596).
?DOC(false).
-spec encode_lzma_length(
encoder(),
integer(),
integer(),
integer(),
integer(),
integer(),
integer(),
integer()
) -> encoder().
encode_lzma_length(
Encoder,
Pos_state,
Length,
T_choice,
T_choice2,
T_low,
T_mid,
T_high
) ->
Value = Length - 2,
case Value < 8 of
true ->
Encoder@1 = encode_bit(Encoder, prob_key(T_choice, 0), 0),
encode_bit_tree(Encoder@1, T_low, Pos_state * 8, 3, Value);
false ->
case Value < (8 + 8) of
true ->
Encoder@2 = encode_bit(Encoder, prob_key(T_choice, 0), 1),
Encoder@3 = encode_bit(Encoder@2, prob_key(T_choice2, 0), 0),
Mid_value = Value - 8,
encode_bit_tree(
Encoder@3,
T_mid,
Pos_state * 8,
3,
Mid_value
);
false ->
Encoder@4 = encode_bit(Encoder, prob_key(T_choice, 0), 1),
Encoder@5 = encode_bit(Encoder@4, prob_key(T_choice2, 0), 1),
High_value = (Value - 8) - 8,
encode_bit_tree(Encoder@5, T_high, 0, 8, High_value)
end
end.
-file("src/packkit/internal/lzma.gleam", 1518).
?DOC(false).
-spec emit_lzma_rep_match(encoder(), integer(), integer(), integer()) -> encoder().
emit_lzma_rep_match(Encoder, Pos_state, Length, Slot) ->
Encoder@1 = encode_bit(Encoder, prob_key(1, erlang:element(6, Encoder)), 1),
Encoder@8 = case Slot of
0 ->
Encoder@2 = encode_bit(
Encoder@1,
prob_key(2, erlang:element(6, Encoder@1)),
0
),
encode_bit(
Encoder@2,
prob_key(5, (erlang:element(6, Encoder@2) * 16) + Pos_state),
1
);
1 ->
Encoder@3 = encode_bit(
Encoder@1,
prob_key(2, erlang:element(6, Encoder@1)),
1
),
encode_bit(Encoder@3, prob_key(3, erlang:element(6, Encoder@3)), 0);
2 ->
Encoder@4 = encode_bit(
Encoder@1,
prob_key(2, erlang:element(6, Encoder@1)),
1
),
Encoder@5 = encode_bit(
Encoder@4,
prob_key(3, erlang:element(6, Encoder@4)),
1
),
encode_bit(Encoder@5, prob_key(4, erlang:element(6, Encoder@5)), 0);
_ ->
Encoder@6 = encode_bit(
Encoder@1,
prob_key(2, erlang:element(6, Encoder@1)),
1
),
Encoder@7 = encode_bit(
Encoder@6,
prob_key(3, erlang:element(6, Encoder@6)),
1
),
encode_bit(Encoder@7, prob_key(4, erlang:element(6, Encoder@7)), 1)
end,
Encoder@9 = encode_lzma_length(
Encoder@8,
Pos_state,
Length,
15,
16,
17,
18,
19
),
{New_rep0, New_rep1, New_rep2, New_rep3} = case Slot of
0 ->
{erlang:element(7, Encoder@9),
erlang:element(8, Encoder@9),
erlang:element(9, Encoder@9),
erlang:element(10, Encoder@9)};
1 ->
{erlang:element(8, Encoder@9),
erlang:element(7, Encoder@9),
erlang:element(9, Encoder@9),
erlang:element(10, Encoder@9)};
2 ->
{erlang:element(9, Encoder@9),
erlang:element(7, Encoder@9),
erlang:element(8, Encoder@9),
erlang:element(10, Encoder@9)};
_ ->
{erlang:element(10, Encoder@9),
erlang:element(7, Encoder@9),
erlang:element(8, Encoder@9),
erlang:element(9, Encoder@9)}
end,
{encoder,
erlang:element(2, Encoder@9),
erlang:element(3, Encoder@9),
erlang:element(4, Encoder@9),
erlang:element(5, Encoder@9),
lzma_rep_next_state(erlang:element(6, Encoder@9)),
New_rep0,
New_rep1,
New_rep2,
New_rep3,
erlang:element(11, Encoder@9),
erlang:element(12, Encoder@9),
erlang:element(13, Encoder@9),
erlang:element(14, Encoder@9) + Length,
erlang:element(15, Encoder@9)}.
-file("src/packkit/internal/lzma.gleam", 1762).
?DOC(false).
-spec encode_reverse_bit_tree_loop(
encoder(),
integer(),
integer(),
integer(),
integer(),
integer(),
integer()
) -> encoder().
encode_reverse_bit_tree_loop(
Encoder,
Table,
Base,
Remaining,
Context,
Value,
Emitted
) ->
case Remaining of
0 ->
Encoder;
_ ->
Bit = erlang:'band'(erlang:'bsr'(Value, Emitted), 1),
Encoder@1 = encode_bit(
Encoder,
prob_key(Table, Base + Context),
Bit
),
encode_reverse_bit_tree_loop(
Encoder@1,
Table,
Base,
Remaining - 1,
(Context * 2) + Bit,
Value,
Emitted + 1
)
end.
-file("src/packkit/internal/lzma.gleam", 1752).
?DOC(false).
-spec encode_reverse_bit_tree(
encoder(),
integer(),
integer(),
integer(),
integer()
) -> encoder().
encode_reverse_bit_tree(Encoder, Table, Base, Num_bits, Value) ->
encode_reverse_bit_tree_loop(Encoder, Table, Base, Num_bits, 1, Value, 0).
-file("src/packkit/internal/lzma.gleam", 1809).
?DOC(false).
-spec encode_direct_bit(encoder(), integer()) -> encoder().
encode_direct_bit(Encoder, Bit) ->
New_range = erlang:'bsr'(erlang:element(2, Encoder), 1),
Encoder@1 = case Bit of
0 ->
{encoder,
New_range,
erlang:element(3, Encoder),
erlang:element(4, Encoder),
erlang:element(5, Encoder),
erlang:element(6, Encoder),
erlang:element(7, Encoder),
erlang:element(8, Encoder),
erlang:element(9, Encoder),
erlang:element(10, Encoder),
erlang:element(11, Encoder),
erlang:element(12, Encoder),
erlang:element(13, Encoder),
erlang:element(14, Encoder),
erlang:element(15, Encoder)};
_ ->
{encoder,
New_range,
erlang:element(3, Encoder) + New_range,
erlang:element(4, Encoder),
erlang:element(5, Encoder),
erlang:element(6, Encoder),
erlang:element(7, Encoder),
erlang:element(8, Encoder),
erlang:element(9, Encoder),
erlang:element(10, Encoder),
erlang:element(11, Encoder),
erlang:element(12, Encoder),
erlang:element(13, Encoder),
erlang:element(14, Encoder),
erlang:element(15, Encoder)}
end,
normalize_encoder(Encoder@1).
-file("src/packkit/internal/lzma.gleam", 1793).
?DOC(false).
-spec encode_direct_bits_loop(encoder(), integer(), integer()) -> encoder().
encode_direct_bits_loop(Encoder, Value, Remaining) ->
case Remaining of
0 ->
Encoder;
_ ->
Bit_pos = Remaining - 1,
Bit = erlang:'band'(erlang:'bsr'(Value, Bit_pos), 1),
Encoder@1 = encode_direct_bit(Encoder, Bit),
encode_direct_bits_loop(Encoder@1, Value, Remaining - 1)
end.
-file("src/packkit/internal/lzma.gleam", 1789).
?DOC(false).
-spec encode_direct_bits(encoder(), integer(), integer()) -> encoder().
encode_direct_bits(Encoder, Value, Num_bits) ->
encode_direct_bits_loop(Encoder, Value, Num_bits).
-file("src/packkit/internal/lzma.gleam", 1645).
?DOC(false).
-spec encode_lzma_distance(encoder(), integer(), integer()) -> encoder().
encode_lzma_distance(Encoder, Distance, Length) ->
Len_state = case (Length - 2) < 4 of
true ->
Length - 2;
false ->
4 - 1
end,
Pos_slot = compute_pos_slot(Distance),
Encoder@1 = encode_bit_tree(Encoder, 7, Len_state * 64, 6, Pos_slot),
case Pos_slot < 4 of
true ->
Encoder@1;
false ->
Num_direct_bits = erlang:'bsr'(Pos_slot, 1) - 1,
Base = erlang:'bsl'(
erlang:'bor'(2, erlang:'band'(Pos_slot, 1)),
Num_direct_bits
),
case Pos_slot < 14 of
true ->
Offset = Base - Pos_slot,
Extra = Distance - Base,
encode_reverse_bit_tree(
Encoder@1,
8,
Offset,
Num_direct_bits,
Extra
);
false ->
High_bits = Num_direct_bits - 4,
Extra@1 = Distance - Base,
Top = erlang:'bsr'(Extra@1, 4),
Encoder@2 = encode_direct_bits(Encoder@1, Top, High_bits),
Align_value = erlang:'band'(Extra@1, mask_for(4)),
encode_reverse_bit_tree(Encoder@2, 9, 0, 4, Align_value)
end
end.
-file("src/packkit/internal/lzma.gleam", 1488).
?DOC(false).
-spec emit_lzma_new_distance_match(encoder(), integer(), integer(), integer()) -> encoder().
emit_lzma_new_distance_match(Encoder, Pos_state, Length, Distance_value) ->
Encoder@1 = encode_bit(Encoder, prob_key(1, erlang:element(6, Encoder)), 0),
Encoder@2 = encode_lzma_length(
Encoder@1,
Pos_state,
Length,
10,
11,
12,
13,
14
),
Encoder@3 = encode_lzma_distance(Encoder@2, Distance_value, Length),
{encoder,
erlang:element(2, Encoder@3),
erlang:element(3, Encoder@3),
erlang:element(4, Encoder@3),
erlang:element(5, Encoder@3),
lzma_match_next_state(erlang:element(6, Encoder@3)),
Distance_value,
erlang:element(7, Encoder@3),
erlang:element(8, Encoder@3),
erlang:element(9, Encoder@3),
erlang:element(11, Encoder@3),
erlang:element(12, Encoder@3),
erlang:element(13, Encoder@3),
erlang:element(14, Encoder@3) + Length,
erlang:element(15, Encoder@3)}.
-file("src/packkit/internal/lzma.gleam", 1454).
?DOC(false).
-spec emit_lzma_match(encoder(), integer(), integer(), integer()) -> encoder().
emit_lzma_match(Encoder, Pos_state, Length, Distance_value) ->
Encoder@1 = encode_bit(
Encoder,
prob_key(0, (erlang:element(6, Encoder) * 16) + Pos_state),
1
),
case which_rep_slot(Encoder@1, Distance_value) of
{some, Slot} ->
emit_lzma_rep_match(Encoder@1, Pos_state, Length, Slot);
none ->
emit_lzma_new_distance_match(
Encoder@1,
Pos_state,
Length,
Distance_value
)
end.
-file("src/packkit/internal/lzma.gleam", 1275).
?DOC(false).
-spec update_hashes_in_range(
bitstring(),
gleam@dict:dict(integer(), integer()),
integer(),
integer(),
integer()
) -> gleam@dict:dict(integer(), integer()).
update_hashes_in_range(Bytes, Hashes, From, To, Size) ->
case (From >= To) orelse ((From + 3) > Size) of
true ->
Hashes;
false ->
Key = lzma_hash3(
byte_at_input(Bytes, From),
byte_at_input(Bytes, From + 1),
byte_at_input(Bytes, From + 2)
),
update_hashes_in_range(
Bytes,
gleam@dict:insert(Hashes, Key, From),
From + 1,
To,
Size
)
end.
-file("src/packkit/internal/lzma.gleam", 1161).
?DOC(false).
-spec lz77_main_loop(
bitstring(),
integer(),
integer(),
encoder(),
gleam@dict:dict(integer(), integer())
) -> encoder().
lz77_main_loop(Bytes, Pos, Size, Encoder, Hashes) ->
case Pos >= Size of
true ->
Encoder;
false ->
case (Pos + 3) > Size of
true ->
Byte = byte_at_input(Bytes, Pos),
Encoder@1 = emit_lzma_literal_or_short_rep(
Encoder,
Bytes,
Pos,
Byte
),
lz77_main_loop(Bytes, Pos + 1, Size, Encoder@1, Hashes);
false ->
B0 = byte_at_input(Bytes, Pos),
B1 = byte_at_input(Bytes, Pos + 1),
B2 = byte_at_input(Bytes, Pos + 2),
Key = lzma_hash3(B0, B1, B2),
case gleam_stdlib:map_get(Hashes, Key) of
{error, _} ->
Encoder@2 = emit_lzma_literal_or_short_rep(
Encoder,
Bytes,
Pos,
B0
),
Hashes@1 = gleam@dict:insert(Hashes, Key, Pos),
lz77_main_loop(
Bytes,
Pos + 1,
Size,
Encoder@2,
Hashes@1
);
{ok, Prev} ->
Distance = Pos - Prev,
case (Distance =< 0) orelse (Distance > 16#8000) of
true ->
Encoder@3 = emit_lzma_literal_or_short_rep(
Encoder,
Bytes,
Pos,
B0
),
Hashes@2 = gleam@dict:insert(
Hashes,
Key,
Pos
),
lz77_main_loop(
Bytes,
Pos + 1,
Size,
Encoder@3,
Hashes@2
);
false ->
Cap = case (Size - Pos) < 273 of
true ->
Size - Pos;
false ->
273
end,
M_len = lzma_match_length(
Bytes,
Prev,
Pos,
Cap,
0
),
case M_len >= 3 of
true ->
Pos_state = erlang:'band'(
Pos,
mask_for(
erlang:element(
4,
erlang:element(
11,
Encoder
)
)
)
),
Encoder@4 = emit_lzma_match(
Encoder,
Pos_state,
M_len,
Distance - 1
),
Hashes@3 = update_hashes_in_range(
Bytes,
gleam@dict:insert(
Hashes,
Key,
Pos
),
Pos + 1,
Pos + M_len,
Size
),
lz77_main_loop(
Bytes,
Pos + M_len,
Size,
Encoder@4,
Hashes@3
);
false ->
Encoder@5 = emit_lzma_literal_or_short_rep(
Encoder,
Bytes,
Pos,
B0
),
Hashes@4 = gleam@dict:insert(
Hashes,
Key,
Pos
),
lz77_main_loop(
Bytes,
Pos + 1,
Size,
Encoder@5,
Hashes@4
)
end
end
end
end
end.
-file("src/packkit/internal/lzma.gleam", 1150).
?DOC(false).
-spec encode_with_lz77(bitstring(), properties()) -> bitstring().
encode_with_lz77(Bytes, Props) ->
Size = erlang:byte_size(Bytes),
Encoder = new_encoder(Props),
Encoder@1 = lz77_main_loop(Bytes, 0, Size, Encoder, maps:new()),
Encoder@2 = finish_encoder(Encoder@1),
list_reverse_to_bit_array(erlang:element(15, Encoder@2), <<>>).