lzma1 0.2.0 → 0.3.0

package/src/index.ts

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright Filip Seman
+ * SPDX-License-Identifier: MIT
+ */
+
+import {
+	type CompressionMode,
+	LZMA,
+} from "./lzma.js";
+
+export type { CompressionMode } from "./lzma.js";
+export { CRC32_TABLE } from "./utils.js";
+
+/**
+ * Compresses data using LZMA algorithm
+ *
+ * @param data Data to compress - can be Uint8Array or ArrayBuffer
+ * @param mode Compression mode (1-9), defaults to 5
+ * @returns Compressed data as a byte array
+ */
+export function compress(
+	data: Uint8Array | ArrayBuffer,
+	mode: CompressionMode = 5,
+): Uint8Array {
+	// Convert ArrayBuffer to Uint8Array if needed
+	const input = data instanceof ArrayBuffer
+		? new Uint8Array(data)
+		: data;
+	const result = new LZMA().compress(input, mode);
+	return new Uint8Array(result);
+}
+
+/**
+ * Compresses data using LZMA algorithm
+ *
+ * @param data String to compress
+ * @param mode Compression mode (1-9), defaults to 5
+ * @returns Compressed data as byte array
+ */
+export function compressString(
+	data: string,
+	mode: CompressionMode = 5,
+): Uint8Array {
+	const compressedData = new LZMA().compressString(data, mode);
+	return new Uint8Array(compressedData);
+}
+
+/**
+ * Decompresses LZMA compressed data
+ *
+ * @param data Compressed data as Uint8Array or ArrayBuffer
+ * @returns Decompressed data
+ */
+export function decompress(data: Uint8Array | ArrayBuffer): Uint8Array {
+	const input = data instanceof ArrayBuffer
+		? new Uint8Array(data)
+		: data;
+	const decompressedData = new LZMA().decompress(input);
+	return new Uint8Array(decompressedData);
+}
+
+/**
+ * Decompresses LZMA compressed data
+ *
+ * @param data Compressed data as Uint8Array or ArrayBuffer
+ * @returns Decompressed data as string
+ */
+export function decompressString(data: Uint8Array | ArrayBuffer): string {
+	return new LZMA().decompressString(data);
+}

package/src/len-coder.ts

@@ -0,0 +1,217 @@
+import {
+	type BitTree,
+	createBitTree,
+	getBitPrice,
+	initArray,
+	initBitModels,
+} from "./utils.js";
+
+/**
+ * Range encoder interface for LenEncoder to communicate with
+ */
+export interface RangeEncoder {
+	encodeBit(probs: number[], index: number, symbol: number): void;
+	encodeBitTree(encoder: BitTree, symbol: number): void;
+}
+
+/**
+ * Length encoder class for LZMA compression
+ * Handles encoding of match lengths with price optimization
+ */
+export class LenEncoder {
+	// Choice probability arrays for length range selection
+	private choice: number[] = initArray(2);
+
+	// Low range coders (for lengths 2-9)
+	private lowCoder: BitTree[] = [];
+
+	// Mid range coders (for lengths 10-17)
+	private midCoder: BitTree[] = [];
+
+	// High range coder (for lengths 18+)
+	private highCoder: BitTree = createBitTree(8);
+
+	// Price optimization properties
+	private tableSize: number = 0;
+	private prices: number[] = [];
+	private counters: number[] = [];
+
+	constructor() {
+		// Initialize low and mid coders for all position states (up to 16)
+		for (let posState = 0; posState < 16; ++posState) {
+			this.lowCoder[posState] = createBitTree(3);
+			this.midCoder[posState] = createBitTree(3);
+		}
+	}
+
+	/**
+	 * Initialize the encoder with specified number of position states
+	 */
+	init(numPosStates: number): void {
+		// Initialize choice probability models
+		initBitModels(this.choice);
+
+		// Initialize low and mid coders for each position state
+		for (let posState = 0; posState < numPosStates; ++posState) {
+			initBitModels(this.lowCoder[posState].models);
+			initBitModels(this.midCoder[posState].models);
+		}
+
+		// Initialize high coder
+		initBitModels(this.highCoder.models);
+	}
+
+	/**
+	 * Encode a length value using the provided range encoder
+	 */
+	encode(symbol: number, posState: number, rangeEncoder: RangeEncoder): void {
+		if (symbol < 8) {
+			// Length 2-9: use low coder
+			rangeEncoder.encodeBit(this.choice, 0, 0);
+			rangeEncoder.encodeBitTree(this.lowCoder[posState], symbol);
+		} else {
+			symbol -= 8;
+			rangeEncoder.encodeBit(this.choice, 0, 1);
+
+			if (symbol < 8) {
+				// Length 10-17: use mid coder
+				rangeEncoder.encodeBit(this.choice, 1, 0);
+				rangeEncoder.encodeBitTree(this.midCoder[posState], symbol);
+			} else {
+				// Length 18+: use high coder
+				rangeEncoder.encodeBit(this.choice, 1, 1);
+				rangeEncoder.encodeBitTree(this.highCoder, symbol - 8);
+			}
+		}
+	}
+
+	/**
+	 * Encode with price table update
+	 */
+	encodeWithUpdate(symbol: number, posState: number, rangeEncoder: RangeEncoder): void {
+		this.encode(symbol, posState, rangeEncoder);
+
+		if (this.counters && (this.counters[posState] -= 1) == 0) {
+			// Reset counter and update prices if needed
+			this.counters[posState] = this.tableSize;
+		}
+	}
+
+	/**
+	 * Get price for encoding a symbol at the given position state
+	 */
+	getPrice(symbol: number, posState: number): number {
+		return this.prices[posState * 0x110 + symbol];
+	}
+
+	/**
+	 * Initialize as a price table encoder
+	 */
+	initPriceTable(): void {
+		this.prices = [];
+		this.counters = [];
+	}
+
+	/**
+	 * Set table size for price optimization
+	 */
+	setTableSize(size: number): void {
+		this.tableSize = size;
+	}
+
+	/**
+	 * Set table size and update internal counters
+	 */
+	setTableSizeAndInitCounters(size: number, numPosStates: number): void {
+		this.tableSize = size;
+		if (this.counters) {
+			for (let posState = 0; posState < numPosStates; ++posState) {
+				this.counters[posState] = size;
+			}
+		}
+	}
+
+	/**
+	 * Get table size
+	 */
+	getTableSize(): number {
+		return this.tableSize;
+	}
+
+	/**
+	 * Update price tables for all position states
+	 */
+	updateTables(numPosStates: number): void {
+		if (!this.prices || !this.counters) {
+			this.initPriceTable();
+		}
+
+		for (let posState = 0; posState < numPosStates; ++posState) {
+			this.setPrices(
+				posState,
+				this.tableSize,
+				this.prices,
+				0,
+			);
+
+			if (this.counters) {
+				this.counters[posState] = this.tableSize;
+			}
+		}
+	}
+
+	// Private methods for internal state management
+
+	/**
+	 * Calculate price for bit tree encoder
+	 */
+	private getBitTreePrice(encoder: BitTree, symbol: number): number {
+		let bit, bitIndex, m = 1, price = 0;
+
+		for (bitIndex = encoder.numBitLevels; bitIndex != 0;) {
+			bitIndex -= 1;
+			bit = symbol >>> bitIndex & 1;
+			price += this.getBitPrice(encoder.models[m], bit);
+			m = (m << 1) + bit;
+		}
+
+		return price;
+	}
+
+	/**
+	 * Get price for a single bit
+	 */
+	private getBitPrice(prob: number, symbol: number): number {
+		return getBitPrice(prob, symbol);
+	}
+
+	/**
+	 * Set prices for all symbols in a position state range
+	 */
+	private setPrices(posState: number, numSymbols: number, prices: number[], priceIndex: number): void {
+		const a0 = this.getBitPrice(this.choice[0], 0);
+		const a1 = this.getBitPrice(this.choice[0], 1);
+		const b0 = a1 + this.getBitPrice(this.choice[1], 0);
+		const b1 = a1 + this.getBitPrice(this.choice[1], 1);
+
+		let i = 0;
+		const st = priceIndex + posState * 0x110;
+
+		// Set prices for low range (lengths 2-9)
+		for (i = 0; i < 8; ++i) {
+			if (i >= numSymbols) return;
+			prices[st + i] = a0 + this.getBitTreePrice(this.lowCoder[posState], i);
+		}
+
+		// Set prices for mid range (lengths 10-17)
+		for (; i < 16; ++i) {
+			if (i >= numSymbols) return;
+			prices[st + i] = b0 + this.getBitTreePrice(this.midCoder[posState], i - 8);
+		}
+
+		// Set prices for high range (lengths 18+)
+		for (; i < numSymbols; ++i) {
+			prices[st + i] = b1 + this.getBitTreePrice(this.highCoder, i - 8 - 8);
+		}
+	}
+}

package/src/lit-coder.ts

@@ -0,0 +1,196 @@
+import {
+	type BasicRangeDecoder,
+	type BasicRangeEncoder,
+	getBitPrice,
+	initArray,
+} from "./utils.js";
+
+export class LitSubCoder {
+	private coders: number[];
+
+	constructor() {
+		this.coders = initArray(0x300, 0x400);
+	}
+
+	/**
+	 * Decode normal literal symbol
+	 */
+	decodeNormal(rd: BasicRangeDecoder): number {
+		let symbol = 1;
+		while (symbol < 0x100) {
+			const i = rd.decodeBit(this.coders, symbol);
+			symbol = (symbol << 1) | i;
+		}
+		return symbol & 0xFF;
+	}
+
+	/**
+	 * Decode literal symbol with match byte context
+	 */
+	decodeWithMatchByte(rd: BasicRangeDecoder, matchByte: number): number {
+		let uMatchByte = matchByte;
+		let symbol = 1;
+
+		while (symbol < 0x100) {
+			const matchBit = (uMatchByte >> 7) & 1;
+			uMatchByte <<= 1;
+			const bit = rd.decodeBit(this.coders, ((1 + matchBit) << 8) + symbol);
+			symbol = (symbol << 1) | bit;
+
+			if (matchBit !== bit) {
+				while (symbol < 0x100) {
+					const i = rd.decodeBit(this.coders, symbol);
+					symbol = (symbol << 1) | i;
+				}
+				break;
+			}
+		}
+		return symbol & 0xFF;
+	}
+
+	/**
+	 * Encode literal symbol
+	 */
+	encode(re: BasicRangeEncoder, symbol: number): void {
+		let context = 1;
+		for (let i = 7; i >= 0; i--) {
+			const bit = (symbol >> i) & 1;
+			re.encodeBit(this.coders, context, bit);
+			context = (context << 1) | bit;
+		}
+	}
+
+	/**
+	 * Encode literal symbol with match byte context
+	 */
+	encodeMatched(re: BasicRangeEncoder, matchByte: number, symbol: number): void {
+		let uMatchByte = matchByte;
+		let context = 1;
+		let same = true;
+
+		for (let i = 7; i >= 0; i--) {
+			const bit = (symbol >> i) & 1;
+			let state = context;
+
+			if (same) {
+				const matchBit = (uMatchByte >> i) & 1;
+				state += (1 + matchBit) << 8;
+				same = matchBit === bit;
+			}
+
+			re.encodeBit(this.coders, state, bit);
+			context = (context << 1) | bit;
+		}
+	}
+
+	/**
+	 * Get price for encoding literal symbol
+	 */
+	getPrice(matchMode: boolean, matchByte: number, symbol: number): number {
+		let uMatchByte = matchByte;
+		let price = 0;
+		let context = 1;
+		let i = 7;
+
+		if (matchMode) {
+			while (i >= 0) {
+				const matchBit = (uMatchByte >> i) & 1;
+				const bit = (symbol >> i) & 1;
+				price += getBitPrice(this.coders[(1 + matchBit) << 8 + context], bit);
+				context = (context << 1) | bit;
+
+				if (matchBit !== bit) {
+					i--;
+					break;
+				}
+				i--;
+			}
+		}
+
+		while (i >= 0) {
+			const bit = (symbol >> i) & 1;
+			price += getBitPrice(this.coders[context], bit);
+			context = (context << 1) | bit;
+			i--;
+		}
+
+		return price;
+	}
+
+	/**
+	 * Reset coder to initial state
+	 */
+	reset(): void {
+		this.coders.fill(1024);
+	}
+
+	/**
+	 * Get decoders array (for compatibility with LiteralDecoderEncoder2)
+	 */
+	get decoders(): number[] {
+		return this.coders;
+	}
+}
+
+export class LitCoder {
+	private _coders: LitSubCoder[];
+	private _numPrevBits: number;
+	private _posMask: number;
+
+	constructor(numPosBits: number, numPrevBits: number) {
+		const numStates = 1 << (numPrevBits + numPosBits);
+		this._coders = [];
+		this._numPrevBits = numPrevBits;
+		this._posMask = (1 << numPosBits) - 1;
+
+		for (let i = 0; i < numStates; i++) {
+			this._coders[i] = new LitSubCoder();
+		}
+	}
+
+	/**
+	 * Get sub-coder for position and previous byte
+	 */
+	getSubCoder(pos: number, prevByte: number): LitSubCoder {
+		return this._coders[
+			((pos & this._posMask) << this._numPrevBits)
+			+ (prevByte >> (8 - this._numPrevBits))
+		];
+	}
+
+	/**
+	 * Reset all sub-coders
+	 */
+	reset(): void {
+		this._coders.forEach((coder) => coder.reset());
+	}
+
+	/**
+	 * Get number of previous bits (for compatibility)
+	 */
+	get numPrevBits(): number {
+		return this._numPrevBits;
+	}
+
+	/**
+	 * Get number of position bits (for compatibility)
+	 */
+	get numPosBits(): number {
+		// Calculate from posMask
+		return Math.log2(this._posMask + 1);
+	}
+
+	/**
+	 * Get position mask (for compatibility)
+	 */
+	get posMask(): number {
+		return this._posMask;
+	}
+
+	/**
+	 * Get coders array (for compatibility)
+	 */
+	get coders(): LitSubCoder[] {
+		return this._coders;
+	}
+}

package/src/lz-window.ts

@@ -0,0 +1,99 @@
+import type { OutputBuffer } from "./streams.js";
+
+export class LzOutWindow {
+	buffer: Uint8Array | null = null;
+	pos: number = 0;
+	streamPos: number = 0;
+	stream: OutputBuffer | null = null;
+	windowSize: number = 0;
+
+	// Private Go-style properties
+	private w: OutputBuffer | null = null;
+	private buf: Uint8Array;
+
+	constructor(writer: OutputBuffer | null = null, windowSize: number = 4096) {
+		this.w = writer;
+		this.stream = writer;
+		this.windowSize = windowSize;
+		this.buf = new Uint8Array(windowSize);
+		this.buffer = this.buf;
+		this.pos = 0;
+		this.streamPos = 0;
+	}
+
+	/**
+	 * Copy a block of data from a previous position (LZ77-style)
+	 */
+	copyBlock(distance: number, length: number): void {
+		if (!this.buffer) return;
+
+		for (let i = 0; i < length; i++) {
+			// Get byte from previous position
+			let sourcePos = this.pos - distance - 1;
+			if (sourcePos < 0) {
+				sourcePos += this.windowSize;
+			}
+
+			const byte = this.buffer[sourcePos];
+			this.putByte(byte);
+		}
+	}
+
+	/**
+	 * Put a single byte into the window
+	 */
+	putByte(byte: number): void {
+		if (!this.buffer) return;
+
+		this.buffer[this.pos] = byte;
+		this.pos++;
+		this.streamPos++;
+
+		if (this.pos >= this.windowSize) {
+			this.flush();
+		}
+	}
+
+	/**
+	 * Get a byte from a relative position
+	 */
+	getByte(relativePos: number): number {
+		if (!this.buffer) return 0;
+
+		let pos = this.pos + relativePos;
+		if (pos < 0) {
+			pos += this.windowSize;
+		} else if (pos >= this.windowSize) {
+			pos -= this.windowSize;
+		}
+		return this.buffer[pos];
+	}
+
+	/**
+	 * Flush buffered data to output writer
+	 */
+	flush(): void {
+		if (this.w && this.buffer && this.pos > 0) {
+			this.w.writeBytes(this.buffer, 0, this.pos);
+			this.pos = 0;
+		}
+	}
+
+	/**
+	 * Check if the window is empty
+	 */
+	isEmpty(): boolean {
+		return this.streamPos === 0;
+	}
+
+	/**
+	 * Reset the window
+	 */
+	reset(): void {
+		this.pos = 0;
+		this.streamPos = 0;
+		if (this.buffer) {
+			this.buffer.fill(0);
+		}
+	}
+}

package/src/lzma.ts

@@ -0,0 +1,142 @@
+import { Decoder } from "./decoder.js";
+import { Encoder } from "./encoder.js";
+import {
+	InputBuffer,
+	OutputBuffer,
+} from "./streams.js";
+
+interface Mode {
+	searchDepth: number;
+	filterStrength: number;
+	modeIndex: number;
+}
+
+/**
+ * LZMA compression mode levels (1-9)
+ * Higher values provide better compression but are slower
+ */
+export type CompressionMode = keyof typeof MODES;
+
+/**
+ * Compression modes
+ */
+export const MODES = {
+	1: { searchDepth: 0x10, filterStrength: 0x40, modeIndex: 0x00 },
+	2: { searchDepth: 0x14, filterStrength: 0x40, modeIndex: 0x00 },
+	3: { searchDepth: 0x13, filterStrength: 0x40, modeIndex: 0x01 },
+	4: { searchDepth: 0x14, filterStrength: 0x40, modeIndex: 0x01 },
+	5: { searchDepth: 0x15, filterStrength: 0x80, modeIndex: 0x01 },
+	6: { searchDepth: 0x16, filterStrength: 0x80, modeIndex: 0x01 },
+	7: { searchDepth: 0x17, filterStrength: 0x80, modeIndex: 0x01 },
+	8: { searchDepth: 0x18, filterStrength: 0xFF, modeIndex: 0x01 },
+	9: { searchDepth: 0x19, filterStrength: 0xFF, modeIndex: 0x01 },
+} as const;
+
+export class LZMA {
+	#encoder = new Encoder();
+	#decoder = new Decoder();
+
+	public compress(
+		data: Uint8Array | ArrayBuffer,
+		mode: CompressionMode = 5,
+	): Int8Array {
+		const inputData = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+		const output = new OutputBuffer(Math.max(32, Math.ceil(inputData.length * 1.2)));
+		const input = new InputBuffer(inputData);
+
+		this.#encoder.compress(input, output, MODES[mode]);
+
+		const result = output.toArray();
+		return new Int8Array(result.buffer, result.byteOffset, result.byteLength);
+	}
+
+	public compressString(
+		data: string,
+		mode: CompressionMode = 5,
+	): Int8Array {
+		return this.compress(new Uint8Array(this.#encodeString(data)), mode);
+	}
+
+	public decompress(bytearray: Uint8Array | ArrayBuffer): Uint8Array {
+		const inputData = bytearray instanceof ArrayBuffer ? new Uint8Array(bytearray) : bytearray;
+		const output = new OutputBuffer(Math.max(32, inputData.length * 2));
+		const input = new InputBuffer(inputData);
+
+		this.#decoder.decompress(input, output);
+
+		return output.toArray();
+	}
+
+	public decompressString(bytearray: Uint8Array | ArrayBuffer): string {
+		const decodedByteArray = this.decompress(bytearray);
+		const result = this.#decodeUTF8(decodedByteArray);
+
+		if (typeof result === "string") {
+			return result;
+		}
+		return String.fromCharCode(...result);
+	}
+
+	#encodeString(inputString: string): number[] {
+		const l = inputString.length;
+		const chars: number[] = [];
+		for (let i = 0; i < l; ++i) {
+			chars[i] = inputString.charCodeAt(i);
+		}
+
+		const data: number[] = [];
+		let elen = 0;
+		for (let i = 0; i < l; ++i) {
+			const ch = chars[i];
+			if (ch >= 1 && ch <= 0x7F) {
+				data[elen++] = ch << 24 >> 24;
+			} else if (!ch || ch >= 0x80 && ch <= 0x7FF) {
+				data[elen++] = (0xC0 | ch >> 6 & 0x1F) << 24 >> 24;
+				data[elen++] = (0x80 | ch & 0x3F) << 24 >> 24;
+			} else {
+				data[elen++] = (0xE0 | ch >> 12 & 0x0F) << 24 >> 24;
+				data[elen++] = (0x80 | ch >> 6 & 0x3F) << 24 >> 24;
+				data[elen++] = (0x80 | ch & 0x3F) << 24 >> 24;
+			}
+		}
+
+		return data;
+	}
+
+	#decodeUTF8(utf: Uint8Array): string | Uint8Array {
+		let j = 0, x, y, z, l = utf.length, buf: string[] = [], charCodes: number[] = [];
+
+		for (let i = 0; i < l; ++i, ++j) {
+			x = utf[i] & 0xFF;
+			if (!(x & 0x80)) {
+				if (!x) return utf;
+				charCodes[j] = x;
+			} else if ((x & 0xE0) == 0xC0) {
+				if (i + 1 >= l) return String.fromCharCode(...utf);
+				y = utf[++i] & 0xFF;
+				if ((y & 0xC0) != 0x80) return String.fromCharCode(...utf);
+				charCodes[j] = ((x & 0x1F) << 6) | (y & 0x3F);
+			} else if ((x & 0xF0) == 0xE0) {
+				if (i + 2 >= l) return utf;
+				y = utf[++i] & 0xFF;
+				if ((y & 0xC0) != 0x80) return utf;
+				z = utf[++i] & 0xFF;
+				if ((z & 0xC0) != 0x80) return utf;
+				charCodes[j] = ((x & 0x0F) << 0x0C) | ((y & 0x3F) << 6) | (z & 0x3F);
+			} else {
+				return utf;
+			}
+			if (j == 0x3FFF) {
+				buf.push(String.fromCharCode.apply(String, charCodes));
+				j = -1;
+			}
+		}
+
+		if (j > 0) {
+			charCodes.length = j;
+			buf.push(String.fromCharCode.apply(String, charCodes));
+		}
+
+		return buf.join("");
+	}
+}