@patrickdk77/archive-defuse 0.1.1 → 0.1.3

package/dist/lzma1/lzma-encoder.d.ts

@@ -6,13 +6,21 @@
  * - `LzmaEncoderFast` uses simple heuristics (levels 1-3).
  * - `LzmaEncoderNormal` searches for the cheapest symbol sequence (levels 4-9).
  *
- * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/lzma/LZMAEncoder.java`,
+ * by Lasse Collin and Igor Pavlov. The LZMA2 entry points and chunk limits
+ * are not ported; this library produces only LZMA1 (".lzma") streams. The
+ * inner coder classes take their outer encoder (or the range encoder) as
+ * an explicit parameter where Java captures it implicitly.
  */
 import type { LzEncoder, Matches } from './lz-encoder';
-import { LzmaCoder } from './lzma-coder';
+import { LengthCoder, LiteralCoder, LzmaCoder } from './lzma-coder';
 import { type Probs } from './range-coder';
 import { type RangeEncoder } from './range-encoder';
-/** Returns the distance slot: roughly 2 * log2(dist), plus the next bit. */
+/**
+ * Gets an integer [0, 63] matching the highest two bits of an integer.
+ * This is like bit scan reverse (BSR) on x86 except that this also
+ * cares about the second highest bit.
+ */
 export declare function getDistSlot(dist: number): number;
 export interface LzmaEncoderConfig {
     lc: number;
@@ -24,18 +32,18 @@ export interface LzmaEncoderConfig {
 export declare abstract class LzmaEncoder extends LzmaCoder {
     private rc;
     readonly lz: LzEncoder;
-    readonly niceLen: number;
+    readonly literalEncoder: LiteralEncoder;
     readonly matchLenEncoder: LengthEncoder;
     readonly repLenEncoder: LengthEncoder;
+    readonly niceLen: number;
     private distPriceCount;
     private alignPriceCount;
-    /** Whether a distance or align bits were encoded since the last reset. */
+    /** Whether a distance was encoded since the last reset. */
     private distModelsUsed;
+    /** Whether align bits were encoded since the last reset. */
     private alignModelUsed;
     private readonly distSlotPricesSize;
-    /** Price of each distance slot per distance state, `[distState << 6 | slot]`. */
     private readonly distSlotPrices;
-    /** Price of each distance below `FULL_DISTANCES` per distance state, `[distState << 7 | dist]`. */
     private readonly fullDistPrices;
     private readonly alignPrices;
     /**
@@ -43,63 +51,83 @@ export declare abstract class LzmaEncoder extends LzmaCoder {
      * -1 = literal, 0-3 = rep match, 4+ = match with distance `back - REPS`.
      */
     protected back: number;
-    /** Bytes the match finder is ahead of the encoder. */
-    protected readAhead: number;
+    /** Bytes the match finder is ahead of the encoder. Package-private in Java. */
+    readAhead: number;
     constructor(rc: RangeEncoder, lz: LzEncoder, config: LzmaEncoderConfig);
-    /** Prepares for a new, independent input written to `rc`. */
+    /**
+     * Prepares for a new, independent input written to `rc` (contract
+     * adaptation: lets a pooled encoder be reused by a later call).
+     */
     restart(rc: RangeEncoder): void;
     /**
-     * Chooses the next symbol: sets `back` and returns its length.
+     * Gets the next LZMA symbol.
+     *
+     * There are three types of symbols: literal (a single byte),
+     * repeated match, and normal match. The symbol is indicated
+     * by the return value and by the variable `back`.
+     *
+     * Literal: `back == -1` and return value is `1`.
+     * The literal itself needs to be read from `lz` separately.
+     *
+     * Repeated match: `back` is in the range [0, 3] and
+     * the return value is the length of the repeated match.
+     *
+     * Normal match: `back - REPS` (`back - 4`)
+     * is the distance of the match and the return value is the length
+     * of the match.
      */
     protected abstract getNextSymbol(): number;
     reset(): void;
-    /** Encodes as much of the buffered input as the lookahead allows. */
+    /** Compress for LZMA1. */
     encode(): void;
-    /** Encodes the end marker: a match with distance 0xFFFFFFFF. */
     encodeEndMarker(): void;
-    /** The first symbol is always a literal with no previous byte. */
     private encodeInit;
     private encodeSymbol;
-    private encodeLiteral;
     private encodeMatch;
     private encodeRepMatch;
     protected getMatches(): Matches;
     protected skip(len: number): void;
-    protected getLiteralPrice(curByte: number, matchByte: number, prevByte: number, pos: number, state: number): number;
-    protected getAnyMatchPrice(state: number, posState: number): number;
-    protected getNormalMatchPrice(anyMatchPrice: number, state: number): number;
-    protected getAnyRepPrice(anyMatchPrice: number, state: number): number;
-    protected getShortRepPrice(anyRepPrice: number, state: number, posState: number): number;
-    protected getLongRepPrice(anyRepPrice: number, rep: number, state: number, posState: number): number;
-    protected getLongRepAndLenPrice(rep: number, len: number, state: number, posState: number): number;
-    protected getMatchAndLenPrice(normalMatchPrice: number, dist: number, len: number, posState: number): number;
-    /** Price of coding `dist` in distance state `distState`. */
-    protected getDistPrice(distState: number, dist: number): number;
-    /** Refreshes the price tables that are due for an update. */
-    protected updatePrices(): void;
+    getAnyMatchPrice(state: number, posState: number): number;
+    getNormalMatchPrice(anyMatchPrice: number, state: number): number;
+    getAnyRepPrice(anyMatchPrice: number, state: number): number;
+    getShortRepPrice(anyRepPrice: number, state: number, posState: number): number;
+    getLongRepPrice(anyRepPrice: number, rep: number, state: number, posState: number): number;
+    getLongRepAndLenPrice(rep: number, len: number, state: number, posState: number): number;
+    getDistPrice(distState: number, dist: number): number;
+    getMatchAndLenPrice(normalMatchPrice: number, dist: number, len: number, posState: number): number;
     private updateDistPrices;
     private updateAlignPrices;
+    /**
+     * Updates the lookup tables used for calculating match distance
+     * and length prices. The updating is skipped for performance reasons
+     * if the tables haven't changed much since the previous update.
+     */
+    updatePrices(): void;
 }
-/**
- * Length encoder with cached prices. Prices of each position state are
- * recalculated after every `LEN_PRICE_UPDATE_INTERVAL` encoded lengths.
- */
-export declare class LengthEncoder {
-    private readonly probs;
-    /** Offset of this length coder in `probs`. */
-    private readonly coder;
+export declare class LiteralEncoder extends LiteralCoder {
+    private readonly encoder;
+    private readonly subencoders;
+    constructor(encoder: LzmaEncoder, lc: number, lp: number);
+    encodeInit(rc: RangeEncoder): void;
+    encode(rc: RangeEncoder): void;
+    getPrice(curByte: number, matchByte: number, prevByte: number, pos: number, state: number): number;
+}
+export declare class LengthEncoder extends LengthCoder {
+    /**
+     * The prices are updated after at least
+     * `PRICE_UPDATE_INTERVAL` many lengths
+     * have been encoded with the same posState.
+     */
+    private static readonly PRICE_UPDATE_INTERVAL;
     private readonly counters;
+    private readonly prices;
     /** Whether a length was encoded since the last reset. */
     private used;
-    /** Prices per position state, `[posState * lenSymbols + len - MATCH_LEN_MIN]`. */
-    readonly prices: Uint32Array;
-    readonly lenSymbols: number;
     constructor(probs: Probs, coder: number, pb: number, niceLen: number);
     reset(): void;
     encode(rc: RangeEncoder, lenIn: number, posState: number): void;
     getPrice(len: number, posState: number): number;
-    /** Offset in `prices` such that `prices[offset + len]` is the price of `len`. */
-    priceOffset(posState: number): number;
+    getPriceRow(posState: number): Int32Array;
     updatePrices(): void;
     private updatePosStatePrices;
 }