@push.rocks/smartarchive 4.2.4 → 5.0.0

package/ts/bzip2/bzip2.ts

@@ -1,23 +1,22 @@
-export class Bzip2Error extends Error {
-  public name: string = 'Bzip2Error';
-  public message: string;
-  public stack = new Error().stack;
-
-  constructor(messageArg: string) {
-    super();
-    this.message = messageArg;
-  }
-}
+import { Bzip2Error, BZIP2_ERROR_CODES } from '../errors.js';
+import type { IBitReader, IHuffmanGroup } from '../interfaces.js';
 
-var messageArg = {
-  Error: function (message) {
-    throw new Bzip2Error(message);
-  },
-};
+// Re-export Bzip2Error for backward compatibility
+export { Bzip2Error };
 
+/**
+ * Throw a BZIP2 error with proper error code
+ */
+function throwError(message: string, code: string = BZIP2_ERROR_CODES.INVALID_BLOCK_DATA): never {
+  throw new Bzip2Error(message, code);
+}
+
+/**
+ * BZIP2 decompression implementation
+ */
 export class Bzip2 {
-  public Bzip2Error = Bzip2Error;
-  public crcTable = [
+  // CRC32 lookup table for BZIP2
+  public readonly crcTable: readonly number[] = [
     0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
     0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
     0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7,
@@ -63,14 +62,24 @@ export class Bzip2 {
     0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4,
   ];
 
-  array = function (bytes) {
-    var bit = 0,
-      byte = 0;
-    var BITMASK = [0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff];
-    return function (n) {
-      var result = 0;
+  // State arrays initialized in header()
+  private byteCount!: Int32Array;
+  private symToByte!: Uint8Array;
+  private mtfSymbol!: Int32Array;
+  private selectors!: Uint8Array;
+
+  /**
+   * Create a bit reader from a byte array
+   */
+  array(bytes: Uint8Array | Buffer): (n: number) => number {
+    let bit = 0;
+    let byte = 0;
+    const BITMASK = [0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff];
+
+    return function (n: number): number {
+      let result = 0;
       while (n > 0) {
-        var left = 8 - bit;
+        const left = 8 - bit;
         if (n >= left) {
           result <<= left;
           result |= BITMASK[left] & bytes[byte++];
@@ -78,234 +87,341 @@ export class Bzip2 {
           n -= left;
         } else {
           result <<= n;
-          result |=
-            (bytes[byte] & (BITMASK[n] << (8 - n - bit))) >> (8 - n - bit);
+          result |= (bytes[byte] & (BITMASK[n] << (8 - n - bit))) >> (8 - n - bit);
           bit += n;
           n = 0;
         }
       }
       return result;
     };
-  };
+  }
 
-  simple = function (srcbuffer, stream) {
-    var bits = this.array(srcbuffer);
-    var size = this.header(bits);
-    var ret = false;
-    var bufsize = 100000 * size;
-    var buf = new Int32Array(bufsize);
+  /**
+   * Simple decompression from a buffer
+   */
+  simple(srcbuffer: Uint8Array | Buffer, stream: (byte: number) => void): void {
+    const bits = this.array(srcbuffer);
+    const size = this.header(bits as IBitReader);
+    let ret: number | null = 0;
+    const bufsize = 100000 * size;
+    const buf = new Int32Array(bufsize);
 
     do {
-      ret = this.decompress(bits, stream, buf, bufsize);
-    } while (!ret);
-  };
+      ret = this.decompress(bits as IBitReader, stream, buf, bufsize, ret);
+    } while (ret !== null);
+  }
 
-  header = function (bits) {
+  /**
+   * Parse BZIP2 header and return block size
+   */
+  header(bits: IBitReader): number {
     this.byteCount = new Int32Array(256);
     this.symToByte = new Uint8Array(256);
     this.mtfSymbol = new Int32Array(256);
     this.selectors = new Uint8Array(0x8000);
 
-    if (bits(8 * 3) != 4348520) messageArg.Error('No magic number found');
-
-    var i = bits(8) - 48;
-    if (i < 1 || i > 9) messageArg.Error('Not a BZIP archive');
-    return i;
-  };
-
-  decompress = function (bits, stream, buf, bufsize, streamCRC) {
-    var MAX_HUFCODE_BITS = 20;
-    var MAX_SYMBOLS = 258;
-    var SYMBOL_RUNA = 0;
-    var SYMBOL_RUNB = 1;
-    var GROUP_SIZE = 50;
-    var crc = 0 ^ -1;
-
-    for (var h = '', i = 0; i < 6; i++) h += bits(8).toString(16);
-    if (h == '177245385090') {
-      var finalCRC = bits(32) | 0;
-      if (finalCRC !== streamCRC)
-        messageArg.Error('Error in bzip2: crc32 do not match');
-      // align stream to byte
+    if (bits(8 * 3) !== 4348520) {
+      throwError('No BZIP2 magic number found at start of stream', BZIP2_ERROR_CODES.NO_MAGIC_NUMBER);
+    }
+
+    const blockSize = (bits(8) as number) - 48;
+    if (blockSize < 1 || blockSize > 9) {
+      throwError('Invalid BZIP2 archive: block size must be 1-9', BZIP2_ERROR_CODES.INVALID_ARCHIVE);
+    }
+    return blockSize;
+  }
+
+  /**
+   * Decompress a BZIP2 block
+   */
+  decompress(
+    bits: IBitReader,
+    stream: (byte: number) => void,
+    buf: Int32Array,
+    bufsize: number,
+    streamCRC?: number | null
+  ): number | null {
+    const MAX_HUFCODE_BITS = 20;
+    const MAX_SYMBOLS = 258;
+    const SYMBOL_RUNA = 0;
+    const SYMBOL_RUNB = 1;
+    const GROUP_SIZE = 50;
+    let crc = 0 ^ -1;
+
+    // Read block header
+    let headerHex = '';
+    for (let i = 0; i < 6; i++) {
+      headerHex += (bits(8) as number).toString(16);
+    }
+
+    // Check for end-of-stream marker
+    if (headerHex === '177245385090') {
+      const finalCRC = bits(32) as number | 0;
+      if (finalCRC !== streamCRC) {
+        throwError('CRC32 mismatch: stream checksum verification failed', BZIP2_ERROR_CODES.CRC_MISMATCH);
+      }
+      // Align stream to byte boundary
       bits(null);
-      return null; // reset streamCRC for next call
+      return null;
     }
-    if (h != '314159265359') messageArg.Error('eek not valid bzip data');
-    var crcblock = bits(32) | 0; // CRC code
-    if (bits(1)) messageArg.Error('unsupported obsolete version');
-    var origPtr = bits(24);
-    if (origPtr > bufsize)
-      messageArg.Error('Initial position larger than buffer size');
-    var t = bits(16);
-    var symTotal = 0;
-    for (i = 0; i < 16; i++) {
-      if (t & (1 << (15 - i))) {
-        var k = bits(16);
-        for (j = 0; j < 16; j++) {
-          if (k & (1 << (15 - j))) {
+
+    // Verify block signature (pi digits)
+    if (headerHex !== '314159265359') {
+      throwError('Invalid block header: expected pi signature (0x314159265359)', BZIP2_ERROR_CODES.INVALID_BLOCK_DATA);
+    }
+
+    const crcblock = bits(32) as number | 0;
+
+    if (bits(1)) {
+      throwError('Unsupported obsolete BZIP2 format version', BZIP2_ERROR_CODES.INVALID_ARCHIVE);
+    }
+
+    const origPtr = bits(24) as number;
+    if (origPtr > bufsize) {
+      throwError('Initial position larger than buffer size', BZIP2_ERROR_CODES.BUFFER_OVERFLOW);
+    }
+
+    // Read symbol map
+    let symbolMapBits = bits(16) as number;
+    let symTotal = 0;
+    for (let i = 0; i < 16; i++) {
+      if (symbolMapBits & (1 << (15 - i))) {
+        const subMap = bits(16) as number;
+        for (let j = 0; j < 16; j++) {
+          if (subMap & (1 << (15 - j))) {
             this.symToByte[symTotal++] = 16 * i + j;
           }
         }
       }
     }
 
-    var groupCount = bits(3);
-    if (groupCount < 2 || groupCount > 6) messageArg.Error('another error');
-    var nSelectors = bits(15);
-    if (nSelectors == 0) messageArg.Error('meh');
-    for (var i = 0; i < groupCount; i++) this.mtfSymbol[i] = i;
-
-    for (var i = 0; i < nSelectors; i++) {
-      for (var j = 0; bits(1); j++)
-        if (j >= groupCount) messageArg.Error('whoops another error');
-      var uc = this.mtfSymbol[j];
-      for (var k: any = j - 1; k >= 0; k--) {
+    // Read Huffman groups
+    const groupCount = bits(3) as number;
+    if (groupCount < 2 || groupCount > 6) {
+      throwError('Invalid group count: must be between 2 and 6', BZIP2_ERROR_CODES.INVALID_HUFFMAN);
+    }
+
+    const nSelectors = bits(15) as number;
+    if (nSelectors === 0) {
+      throwError('Invalid selector count: cannot be zero', BZIP2_ERROR_CODES.INVALID_SELECTOR);
+    }
+
+    // Initialize MTF symbol array
+    for (let i = 0; i < groupCount; i++) {
+      this.mtfSymbol[i] = i;
+    }
+
+    // Read selectors using MTF decoding
+    for (let i = 0; i < nSelectors; i++) {
+      let j = 0;
+      while (bits(1)) {
+        j++;
+        if (j >= groupCount) {
+          throwError('Invalid MTF index: exceeds group count', BZIP2_ERROR_CODES.INVALID_HUFFMAN);
+        }
+      }
+      const uc = this.mtfSymbol[j];
+      for (let k = j - 1; k >= 0; k--) {
         this.mtfSymbol[k + 1] = this.mtfSymbol[k];
       }
       this.mtfSymbol[0] = uc;
       this.selectors[i] = uc;
     }
 
-    var symCount = symTotal + 2;
-    var groups = [];
-    var length = new Uint8Array(MAX_SYMBOLS),
-      temp = new Uint16Array(MAX_HUFCODE_BITS + 1);
-
-    var hufGroup;
+    // Build Huffman tables
+    const symCount = symTotal + 2;
+    const groups: IHuffmanGroup[] = [];
+    const length = new Uint8Array(MAX_SYMBOLS);
+    const temp = new Uint16Array(MAX_HUFCODE_BITS + 1);
 
-    for (var j = 0; j < groupCount; j++) {
-      t = bits(5); //lengths
-      for (var i = 0; i < symCount; i++) {
+    for (let j = 0; j < groupCount; j++) {
+      let t = bits(5) as number;
+      for (let i = 0; i < symCount; i++) {
         while (true) {
-          if (t < 1 || t > MAX_HUFCODE_BITS)
-            messageArg.Error('I gave up a while ago on writing error messages');
+          if (t < 1 || t > MAX_HUFCODE_BITS) {
+            throwError('Invalid Huffman code length: must be between 1 and 20', BZIP2_ERROR_CODES.INVALID_HUFFMAN);
+          }
           if (!bits(1)) break;
           if (!bits(1)) t++;
           else t--;
         }
         length[i] = t;
       }
-      var minLen, maxLen;
-      minLen = maxLen = length[0];
-      for (var i = 1; i < symCount; i++) {
+
+      let minLen = length[0];
+      let maxLen = length[0];
+      for (let i = 1; i < symCount; i++) {
         if (length[i] > maxLen) maxLen = length[i];
         else if (length[i] < minLen) minLen = length[i];
       }
-      hufGroup = groups[j] = {};
-      hufGroup.permute = new Int32Array(MAX_SYMBOLS);
-      hufGroup.limit = new Int32Array(MAX_HUFCODE_BITS + 1);
-      hufGroup.base = new Int32Array(MAX_HUFCODE_BITS + 1);
-
-      hufGroup.minLen = minLen;
-      hufGroup.maxLen = maxLen;
-      var base = hufGroup.base;
-      var limit = hufGroup.limit;
-      var pp = 0;
-      for (var i: number = minLen; i <= maxLen; i++)
-        for (var t: any = 0; t < symCount; t++)
-          if (length[t] == i) hufGroup.permute[pp++] = t;
-      for (i = minLen; i <= maxLen; i++) temp[i] = limit[i] = 0;
-      for (i = 0; i < symCount; i++) temp[length[i]]++;
-      pp = t = 0;
-      for (i = minLen; i < maxLen; i++) {
+
+      const hufGroup: IHuffmanGroup = {
+        permute: new Int32Array(MAX_SYMBOLS),
+        limit: new Int32Array(MAX_HUFCODE_BITS + 1),
+        base: new Int32Array(MAX_HUFCODE_BITS + 1),
+        minLen,
+        maxLen,
+      };
+      groups[j] = hufGroup;
+
+      const base = hufGroup.base;
+      const limit = hufGroup.limit;
+
+      let pp = 0;
+      for (let i = minLen; i <= maxLen; i++) {
+        for (let t = 0; t < symCount; t++) {
+          if (length[t] === i) hufGroup.permute[pp++] = t;
+        }
+      }
+
+      for (let i = minLen; i <= maxLen; i++) {
+        temp[i] = 0;
+        limit[i] = 0;
+      }
+      for (let i = 0; i < symCount; i++) {
+        temp[length[i]]++;
+      }
+
+      pp = 0;
+      let tt = 0;
+      for (let i = minLen; i < maxLen; i++) {
         pp += temp[i];
         limit[i] = pp - 1;
         pp <<= 1;
-        base[i + 1] = pp - (t += temp[i]);
+        base[i + 1] = pp - (tt += temp[i]);
       }
       limit[maxLen] = pp + temp[maxLen] - 1;
       base[minLen] = 0;
     }
 
-    for (var i = 0; i < 256; i++) {
+    // Initialize for decoding
+    for (let i = 0; i < 256; i++) {
       this.mtfSymbol[i] = i;
       this.byteCount[i] = 0;
     }
-    var runPos, count, symCount: number, selector;
-    runPos = count = symCount = selector = 0;
+
+    let runPos = 0;
+    let count = 0;
+    let symCountRemaining = 0;
+    let selector = 0;
+    let hufGroup = groups[0];
+    let base = hufGroup.base;
+    let limit = hufGroup.limit;
+
+    // Main decoding loop
     while (true) {
-      if (!symCount--) {
-        symCount = GROUP_SIZE - 1;
-        if (selector >= nSelectors)
-          messageArg.Error("meow i'm a kitty, that's an error");
+      if (!symCountRemaining--) {
+        symCountRemaining = GROUP_SIZE - 1;
+        if (selector >= nSelectors) {
+          throwError('Invalid selector index: exceeds available groups', BZIP2_ERROR_CODES.INVALID_SELECTOR);
+        }
         hufGroup = groups[this.selectors[selector++]];
         base = hufGroup.base;
         limit = hufGroup.limit;
       }
-      i = hufGroup.minLen;
-      j = bits(i);
+
+      let i = hufGroup.minLen;
+      let j = bits(i) as number;
+
       while (true) {
-        if (i > hufGroup.maxLen) messageArg.Error("rawr i'm a dinosaur");
+        if (i > hufGroup.maxLen) {
+          throwError('Huffman decoding error: bit length exceeds maximum allowed', BZIP2_ERROR_CODES.INVALID_HUFFMAN);
+        }
         if (j <= limit[i]) break;
         i++;
-        j = (j << 1) | bits(1);
+        j = (j << 1) | (bits(1) as number);
       }
+
       j -= base[i];
-      if (j < 0 || j >= MAX_SYMBOLS) messageArg.Error("moo i'm a cow");
-      var nextSym = hufGroup.permute[j];
-      if (nextSym == SYMBOL_RUNA || nextSym == SYMBOL_RUNB) {
+      if (j < 0 || j >= MAX_SYMBOLS) {
+        throwError('Symbol index out of bounds during Huffman decoding', BZIP2_ERROR_CODES.INVALID_HUFFMAN);
+      }
+
+      const nextSym = hufGroup.permute[j];
+
+      if (nextSym === SYMBOL_RUNA || nextSym === SYMBOL_RUNB) {
         if (!runPos) {
           runPos = 1;
-          t = 0;
+          j = 0;
         }
-        if (nextSym == SYMBOL_RUNA) t += runPos;
-        else t += 2 * runPos;
+        if (nextSym === SYMBOL_RUNA) j += runPos;
+        else j += 2 * runPos;
         runPos <<= 1;
         continue;
       }
+
       if (runPos) {
         runPos = 0;
-        if (count + t > bufsize) messageArg.Error('Boom.');
-        uc = this.symToByte[this.mtfSymbol[0]];
-        this.byteCount[uc] += t;
-        while (t--) buf[count++] = uc;
+        const runLength = j;
+        if (count + runLength > bufsize) {
+          throwError('Run-length overflow: decoded run exceeds buffer capacity', BZIP2_ERROR_CODES.BUFFER_OVERFLOW);
+        }
+        const uc = this.symToByte[this.mtfSymbol[0]];
+        this.byteCount[uc] += runLength;
+        for (let t = 0; t < runLength; t++) {
+          buf[count++] = uc;
+        }
       }
+
       if (nextSym > symTotal) break;
-      if (count >= bufsize)
-        messageArg.Error("I can't think of anything. Error");
-      i = nextSym - 1;
-      uc = this.mtfSymbol[i];
-      for (var k: any = i - 1; k >= 0; k--) {
+
+      if (count >= bufsize) {
+        throwError('Buffer overflow: decoded data exceeds buffer capacity', BZIP2_ERROR_CODES.BUFFER_OVERFLOW);
+      }
+
+      const mtfIndex = nextSym - 1;
+      const uc = this.mtfSymbol[mtfIndex];
+      for (let k = mtfIndex - 1; k >= 0; k--) {
         this.mtfSymbol[k + 1] = this.mtfSymbol[k];
       }
       this.mtfSymbol[0] = uc;
-      uc = this.symToByte[uc];
-      this.byteCount[uc]++;
-      buf[count++] = uc;
+      const decodedByte = this.symToByte[uc];
+      this.byteCount[decodedByte]++;
+      buf[count++] = decodedByte;
     }
-    if (origPtr < 0 || origPtr >= count)
-      messageArg.Error(
-        "I'm a monkey and I'm throwing something at someone, namely you",
-      );
-    var j = 0;
-    for (var i = 0; i < 256; i++) {
-      k = j + this.byteCount[i];
+
+    if (origPtr < 0 || origPtr >= count) {
+      throwError('Invalid original pointer: position outside decoded block', BZIP2_ERROR_CODES.INVALID_POSITION);
+    }
+
+    // Inverse BWT transform
+    let j = 0;
+    for (let i = 0; i < 256; i++) {
+      const k = j + this.byteCount[i];
       this.byteCount[i] = j;
       j = k;
     }
-    for (var i = 0; i < count; i++) {
-      uc = buf[i] & 0xff;
+
+    for (let i = 0; i < count; i++) {
+      const uc = buf[i] & 0xff;
       buf[this.byteCount[uc]] |= i << 8;
       this.byteCount[uc]++;
     }
-    var pos = 0,
-      current = 0,
-      run = 0;
+
+    // Output decoded data
+    let pos = 0;
+    let current = 0;
+    let run = 0;
+
     if (count) {
       pos = buf[origPtr];
       current = pos & 0xff;
       pos >>= 8;
       run = -1;
     }
-    count = count;
-    var copies, previous, outbyte;
-    while (count) {
-      count--;
-      previous = current;
+
+    let remaining = count;
+    while (remaining) {
+      remaining--;
+      const previous = current;
       pos = buf[pos];
       current = pos & 0xff;
       pos >>= 8;
-      if (run++ == 3) {
+
+      let copies: number;
+      let outbyte: number;
+
+      if (run++ === 3) {
         copies = current;
         outbyte = previous;
         current = -1;
@@ -313,19 +429,21 @@ export class Bzip2 {
         copies = 1;
         outbyte = current;
       }
+
       while (copies--) {
-        crc =
-          ((crc << 8) ^ this.crcTable[((crc >> 24) ^ outbyte) & 0xff]) &
-          0xffffffff; // crc32
+        crc = ((crc << 8) ^ this.crcTable[((crc >> 24) ^ outbyte) & 0xff]) & 0xffffffff;
         stream(outbyte);
       }
-      if (current != previous) run = 0;
+
+      if (current !== previous) run = 0;
     }
 
     crc = (crc ^ -1) >>> 0;
-    if ((crc | 0) != (crcblock | 0))
-      messageArg.Error('Error in bzip2: crc32 do not match');
-    streamCRC = (crc ^ ((streamCRC << 1) | (streamCRC >>> 31))) & 0xffffffff;
-    return streamCRC;
-  };
+    if ((crc | 0) !== (crcblock | 0)) {
+      throwError('CRC32 mismatch: block checksum verification failed', BZIP2_ERROR_CODES.CRC_MISMATCH);
+    }
+
+    const newStreamCRC = (crc ^ (((streamCRC || 0) << 1) | ((streamCRC || 0) >>> 31))) & 0xffffffff;
+    return newStreamCRC;
+  }
 }