@push.rocks/smartarchive 5.0.1 → 5.2.0

package/ts/classes.smartarchive.ts

@@ -6,12 +6,15 @@ import type {
   TArchiveFormat,
   TCompressionLevel,
   TEntryFilter,
-} from './interfaces.js';
+} from '../ts_shared/interfaces.js';
 
-import { Bzip2Tools } from './classes.bzip2tools.js';
-import { GzipTools } from './classes.gziptools.js';
+// Import browser-compatible tools from ts_shared
+import { Bzip2Tools } from '../ts_shared/classes.bzip2tools.js';
+import { GzipTools } from '../ts_shared/classes.gziptools.js';
+import { ZipTools } from '../ts_shared/classes.ziptools.js';
+
+// Import Node.js-extended TarTools
 import { TarTools } from './classes.tartools.js';
-import { ZipTools } from './classes.ziptools.js';
 import { ArchiveAnalyzer, type IAnalyzedResult } from './classes.archiveanalyzer.js';
 
 /**
@@ -62,7 +65,7 @@ export class SmartArchive {
   public tarTools = new TarTools();
   public zipTools = new ZipTools();
   public gzipTools = new GzipTools();
-  public bzip2Tools = new Bzip2Tools(this);
+  public bzip2Tools = new Bzip2Tools();
   public archiveAnalyzer = new ArchiveAnalyzer(this);
 
   // ============================================
@@ -173,7 +176,7 @@ export class SmartArchive {
   public entry(archivePath: string, content: string | Buffer): this {
     this.ensureNotInExtractMode('entry');
     if (!this._mode) this._mode = 'create';
-    this.pendingEntries.push({ archivePath, content });
+    this.pendingEntries.push({ archivePath, content: content instanceof Buffer ? new Uint8Array(content) : content });
     return this;
   }
 
@@ -184,7 +187,10 @@ export class SmartArchive {
     this.ensureNotInExtractMode('entries');
     if (!this._mode) this._mode = 'create';
     for (const e of entriesArg) {
-      this.pendingEntries.push({ archivePath: e.archivePath, content: e.content });
+      this.pendingEntries.push({
+        archivePath: e.archivePath,
+        content: e.content instanceof Buffer ? new Uint8Array(e.content) : e.content
+      });
     }
     return this;
   }
@@ -374,30 +380,41 @@ export class SmartArchive {
       plugins.smartstream.createTransformFunction<IAnalyzedResult, void>(
         async (analyzedResultChunk) => {
           if (analyzedResultChunk.fileType?.mime === 'application/x-tar') {
-            const tarStream = analyzedResultChunk.decompressionStream as plugins.tarStream.Extract;
+            // Use tar-stream for streaming TAR extraction
+            // Buffer each entry to ensure tar-stream can proceed to next entry
+            const extract = this.tarTools.getExtractStream();
 
-            tarStream.on('entry', async (header, stream, next) => {
+            extract.on('entry', (header, stream, next) => {
               if (header.type === 'directory') {
-                stream.resume();
-                stream.on('end', () => next());
+                stream.resume(); // Drain the stream
+                next();
                 return;
               }
 
-              const passThrough = new plugins.stream.PassThrough();
-              const streamfile = plugins.smartfile.StreamFile.fromStream(passThrough, header.name);
-              streamFileIntake.push(streamfile);
-              stream.pipe(passThrough);
+              // Buffer the entry content to avoid blocking tar-stream
+              const chunks: Buffer[] = [];
+              stream.on('data', (chunk: Buffer) => chunks.push(chunk));
               stream.on('end', () => {
-                passThrough.end();
+                const content = Buffer.concat(chunks);
+                const streamFile = plugins.smartfile.StreamFile.fromBuffer(content);
+                streamFile.relativeFilePath = header.name;
+                streamFileIntake.push(streamFile);
                 next();
               });
+              stream.on('error', (err: Error) => {
+                streamFileIntake.emit('error', err);
+              });
             });
 
-            tarStream.on('finish', () => {
+            extract.on('finish', () => {
               safeSignalEnd();
             });
 
-            analyzedResultChunk.resultStream.pipe(analyzedResultChunk.decompressionStream);
+            extract.on('error', (err: Error) => {
+              streamFileIntake.emit('error', err);
+            });
+
+            analyzedResultChunk.resultStream.pipe(extract);
           } else if (analyzedResultChunk.fileType?.mime === 'application/zip') {
             analyzedResultChunk.resultStream
               .pipe(analyzedResultChunk.decompressionStream)
@@ -544,25 +561,29 @@ export class SmartArchive {
 
     if (this.creationFormat === 'tar' || this.creationFormat === 'tar.gz' || this.creationFormat === 'tgz') {
       if (this.creationFormat === 'tar') {
-        this.archiveBuffer = await this.tarTools.packFiles(entries);
+        const result = await this.tarTools.packFiles(entries);
+        this.archiveBuffer = Buffer.from(result);
       } else {
-        this.archiveBuffer = await this.tarTools.packFilesToTarGz(entries, this._compressionLevel);
+        const result = await this.tarTools.packFilesToTarGz(entries, this._compressionLevel);
+        this.archiveBuffer = Buffer.from(result);
       }
     } else if (this.creationFormat === 'zip') {
-      this.archiveBuffer = await this.zipTools.createZip(entries, this._compressionLevel);
+      const result = await this.zipTools.createZip(entries, this._compressionLevel);
+      this.archiveBuffer = Buffer.from(result);
     } else if (this.creationFormat === 'gz') {
       if (entries.length !== 1) {
         throw new Error('GZIP format only supports a single file');
       }
-      let content: Buffer;
+      let content: Uint8Array;
       if (typeof entries[0].content === 'string') {
-        content = Buffer.from(entries[0].content);
-      } else if (Buffer.isBuffer(entries[0].content)) {
+        content = new TextEncoder().encode(entries[0].content);
+      } else if (entries[0].content instanceof Uint8Array) {
         content = entries[0].content;
       } else {
-        throw new Error('GZIP format requires string or Buffer content');
+        throw new Error('GZIP format requires string or Uint8Array content');
       }
-      this.archiveBuffer = await this.gzipTools.compress(content, this._compressionLevel);
+      const result = await this.gzipTools.compress(content, this._compressionLevel);
+      this.archiveBuffer = Buffer.from(result);
     } else {
       throw new Error(`Unsupported format: ${this.creationFormat}`);
     }
@@ -808,7 +829,7 @@ export class SmartArchive {
         const content = await plugins.fsPromises.readFile(absolutePath);
         this.pendingEntries.push({
           archivePath,
-          content,
+          content: new Uint8Array(content),
         });
       }
     }

package/ts/classes.tartools.ts

@@ -1,208 +1,272 @@
 import * as plugins from './plugins.js';
-import type { IArchiveEntry, TCompressionLevel } from './interfaces.js';
-import { GzipTools } from './classes.gziptools.js';
+import type { IArchiveEntry, TCompressionLevel } from '../ts_shared/interfaces.js';
+import { TarTools as SharedTarTools } from '../ts_shared/classes.tartools.js';
 
 /**
- * TAR archive creation and extraction utilities
+ * Options for adding a file to a TAR pack stream
  */
-export class TarTools {
+export interface ITarPackFileOptions {
+  fileName: string;
+  content: string | Buffer | Uint8Array | plugins.stream.Readable;
+  size?: number;
+  mode?: number;
+  mtime?: Date;
+}
+
+/**
+ * Extended TAR archive utilities with Node.js streaming support
+ *
+ * For small archives: Use inherited buffer-based methods (packFiles, extractTar, etc.)
+ * For large archives: Use streaming methods (getPackStream, getExtractStream, etc.)
+ */
+export class TarTools extends SharedTarTools {
+  // ============================================
+  // STREAMING PACK METHODS (for large files)
+  // ============================================
+
+  /**
+   * Get a streaming TAR pack instance
+   * Use this for packing large files without buffering everything in memory
+   *
+   * @example
+   * ```typescript
+   * const pack = tarTools.getPackStream();
+   *
+   * await tarTools.addFileToPack(pack, { fileName: 'large.bin', content: readStream, size: fileSize });
+   * await tarTools.addFileToPack(pack, { fileName: 'small.txt', content: 'Hello World' });
+   *
+   * pack.finalize();
+   * pack.pipe(fs.createWriteStream('output.tar'));
+   * ```
+   */
+  public getPackStream(): plugins.tarStream.Pack {
+    return plugins.tarStream.pack();
+  }
+
   /**
    * Add a file to a TAR pack stream
+   * Supports strings, buffers, and readable streams
+   *
+   * @param pack - The pack stream from getPackStream()
+   * @param options - File options including name, content, and optional metadata
    */
   public async addFileToPack(
     pack: plugins.tarStream.Pack,
-    optionsArg: {
-      fileName?: string;
-      content?:
-        | string
-        | Buffer
-        | plugins.stream.Readable
-        | plugins.smartfile.SmartFile
-        | plugins.smartfile.StreamFile;
-      byteLength?: number;
-      filePath?: string;
-    }
+    options: ITarPackFileOptions
   ): Promise<void> {
-    return new Promise<void>(async (resolve, reject) => {
-      let fileName: string | null = null;
-
-      if (optionsArg.fileName) {
-        fileName = optionsArg.fileName;
-      } else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
-        fileName = optionsArg.content.relative;
-      } else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
-        fileName = optionsArg.content.relativeFilePath;
-      } else if (optionsArg.filePath) {
-        fileName = optionsArg.filePath;
-      }
+    const { fileName, content, mode = 0o644, mtime = new Date() } = options;
 
-      if (!fileName) {
-        reject(new Error('No filename specified for TAR entry'));
-        return;
+    if (typeof content === 'string') {
+      // String content - convert to buffer
+      const buffer = Buffer.from(content, 'utf8');
+      const entry = pack.entry({
+        name: fileName,
+        size: buffer.length,
+        mode,
+        mtime,
+      });
+      entry.write(buffer);
+      entry.end();
+    } else if (Buffer.isBuffer(content) || content instanceof Uint8Array) {
+      // Buffer content
+      const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+      const entry = pack.entry({
+        name: fileName,
+        size: buffer.length,
+        mode,
+        mtime,
+      });
+      entry.write(buffer);
+      entry.end();
+    } else if (content && typeof (content as any).pipe === 'function') {
+      // Readable stream - requires size to be provided
+      const size = options.size;
+      if (size === undefined) {
+        throw new Error('Size must be provided when adding a stream to TAR pack');
       }
 
-      // Determine content byte length
-      let contentByteLength: number | undefined;
-      if (optionsArg.byteLength) {
-        contentByteLength = optionsArg.byteLength;
-      } else if (typeof optionsArg.content === 'string') {
-        contentByteLength = Buffer.byteLength(optionsArg.content, 'utf8');
-      } else if (Buffer.isBuffer(optionsArg.content)) {
-        contentByteLength = optionsArg.content.length;
-      } else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
-        contentByteLength = await optionsArg.content.getSize();
-      } else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
-        contentByteLength = await optionsArg.content.getSize();
-      } else if (optionsArg.filePath) {
-        const fileStat = await plugins.fsPromises.stat(optionsArg.filePath);
-        contentByteLength = fileStat.size;
-      }
+      return new Promise<void>((resolve, reject) => {
+        const entry = pack.entry({
+          name: fileName,
+          size,
+          mode,
+          mtime,
+        }, (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
 
-      // Convert all content types to Readable stream
-      let content: plugins.stream.Readable;
-      if (Buffer.isBuffer(optionsArg.content)) {
-        content = plugins.stream.Readable.from(optionsArg.content);
-      } else if (typeof optionsArg.content === 'string') {
-        content = plugins.stream.Readable.from(Buffer.from(optionsArg.content));
-      } else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
-        content = plugins.stream.Readable.from(optionsArg.content.contents);
-      } else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
-        content = await optionsArg.content.createReadStream();
-      } else if (optionsArg.content instanceof plugins.stream.Readable) {
-        content = optionsArg.content;
-      } else if (optionsArg.filePath) {
-        content = plugins.fs.createReadStream(optionsArg.filePath);
-      } else {
-        reject(new Error('No content or filePath specified for TAR entry'));
-        return;
-      }
+        (content as plugins.stream.Readable).pipe(entry);
+      });
+    } else {
+      throw new Error('Unsupported content type for TAR entry');
+    }
+  }
 
-      const entry = pack.entry(
-        {
-          name: fileName,
-          ...(contentByteLength !== undefined ? { size: contentByteLength } : {}),
-        },
-        (err: Error | null) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve();
-          }
-        }
-      );
+  // ============================================
+  // STREAMING EXTRACT METHODS (for large files)
+  // ============================================
 
-      content.pipe(entry);
-      // Note: resolve() is called in the callback above when pipe completes
-    });
+  /**
+   * Get a streaming TAR extract instance
+   * Use this for extracting large archives without buffering everything in memory
+   *
+   * @example
+   * ```typescript
+   * const extract = tarTools.getExtractStream();
+   *
+   * extract.on('entry', (header, stream, next) => {
+   *   console.log(`Extracting: ${header.name}`);
+   *   stream.pipe(fs.createWriteStream(`./out/${header.name}`));
+   *   stream.on('end', next);
+   * });
+   *
+   * fs.createReadStream('archive.tar').pipe(extract);
+   * ```
+   */
+  public getExtractStream(): plugins.tarStream.Extract {
+    return plugins.tarStream.extract();
   }
 
   /**
-   * Pack a directory into a TAR stream
+   * Extract a TAR stream to a directory with true streaming (no buffering)
+   *
+   * @param sourceStream - The TAR archive stream
+   * @param targetDir - Directory to extract files to
    */
-  public async packDirectory(directoryPath: string): Promise<plugins.tarStream.Pack> {
-    const fileTree = await plugins.listFileTree(directoryPath, '**/*');
-    const pack = await this.getPackStream();
+  public async extractToDirectory(
+    sourceStream: plugins.stream.Readable,
+    targetDir: string
+  ): Promise<void> {
+    await plugins.fsPromises.mkdir(targetDir, { recursive: true });
 
-    for (const filePath of fileTree) {
-      const absolutePath = plugins.path.join(directoryPath, filePath);
-      const fileStat = await plugins.fsPromises.stat(absolutePath);
-      await this.addFileToPack(pack, {
-        byteLength: fileStat.size,
-        filePath: absolutePath,
-        fileName: filePath,
-        content: plugins.fs.createReadStream(absolutePath),
+    return new Promise<void>((resolve, reject) => {
+      const extract = this.getExtractStream();
+
+      extract.on('entry', async (header, stream, next) => {
+        const filePath = plugins.path.join(targetDir, header.name);
+
+        if (header.type === 'directory') {
+          await plugins.fsPromises.mkdir(filePath, { recursive: true });
+          stream.resume(); // Drain the stream
+          next();
+        } else if (header.type === 'file') {
+          await plugins.fsPromises.mkdir(plugins.path.dirname(filePath), { recursive: true });
+          const writeStream = plugins.fs.createWriteStream(filePath);
+          stream.pipe(writeStream);
+          writeStream.on('finish', next);
+          writeStream.on('error', reject);
+        } else {
+          stream.resume(); // Skip other types
+          next();
+        }
       });
-    }
 
-    return pack;
+      extract.on('finish', resolve);
+      extract.on('error', reject);
+
+      sourceStream.pipe(extract);
+    });
   }
 
+  // ============================================
+  // STREAMING DIRECTORY PACK (for large directories)
+  // ============================================
+
   /**
-   * Get a new TAR pack stream
+   * Pack a directory into a TAR stream with true streaming (no buffering)
+   * Files are read and written one at a time, never loading everything into memory
    */
-  public async getPackStream(): Promise<plugins.tarStream.Pack> {
-    return plugins.tarStream.pack();
+  public async getDirectoryPackStream(directoryPath: string): Promise<plugins.tarStream.Pack> {
+    const pack = this.getPackStream();
+    const fileTree = await plugins.listFileTree(directoryPath, '**/*');
+
+    // Process files sequentially to avoid memory issues
+    (async () => {
+      for (const filePath of fileTree) {
+        const absolutePath = plugins.path.join(directoryPath, filePath);
+        const stat = await plugins.fsPromises.stat(absolutePath);
+
+        if (stat.isFile()) {
+          const readStream = plugins.fs.createReadStream(absolutePath);
+          await this.addFileToPack(pack, {
+            fileName: filePath,
+            content: readStream,
+            size: stat.size,
+            mode: stat.mode,
+            mtime: stat.mtime,
+          });
+        }
+      }
+      pack.finalize();
+    })().catch((err) => pack.destroy(err));
+
+    return pack;
   }
 
   /**
-   * Get a TAR extraction stream
+   * Pack a directory into a TAR.GZ stream with true streaming
+   * Uses Node.js zlib for streaming compression
    */
-  public getDecompressionStream(): plugins.tarStream.Extract {
-    return plugins.tarStream.extract();
+  public async getDirectoryPackStreamGz(
+    directoryPath: string,
+    compressionLevel?: TCompressionLevel
+  ): Promise<plugins.stream.Readable> {
+    const tarStream = await this.getDirectoryPackStream(directoryPath);
+    const { createGzip } = await import('node:zlib');
+    const gzip = createGzip({ level: compressionLevel ?? 6 });
+    return tarStream.pipe(gzip);
   }
 
+  // ============================================
+  // BUFFER-BASED METHODS (inherited + filesystem)
+  // ============================================
+
   /**
-   * Pack files into a TAR buffer
+   * Pack a directory into a TAR buffer (loads all files into memory)
+   * For large directories, use getDirectoryPackStream() instead
    */
-  public async packFiles(files: IArchiveEntry[]): Promise<Buffer> {
-    const pack = await this.getPackStream();
-
-    for (const file of files) {
-      await this.addFileToPack(pack, {
-        fileName: file.archivePath,
-        content: file.content as string | Buffer | plugins.stream.Readable | plugins.smartfile.SmartFile | plugins.smartfile.StreamFile,
-        byteLength: file.size,
-      });
-    }
+  public async packDirectory(directoryPath: string): Promise<Uint8Array> {
+    const fileTree = await plugins.listFileTree(directoryPath, '**/*');
+    const entries: IArchiveEntry[] = [];
 
-    pack.finalize();
+    for (const filePath of fileTree) {
+      const absolutePath = plugins.path.join(directoryPath, filePath);
+      const stat = await plugins.fsPromises.stat(absolutePath);
 
-    const chunks: Buffer[] = [];
-    return new Promise((resolve, reject) => {
-      pack.on('data', (chunk: Buffer) => chunks.push(chunk));
-      pack.on('end', () => resolve(Buffer.concat(chunks)));
-      pack.on('error', reject);
-    });
+      if (stat.isFile()) {
+        const content = await plugins.fsPromises.readFile(absolutePath);
+        entries.push({
+          archivePath: filePath,
+          content: new Uint8Array(content),
+        });
+      }
+    }
+
+    return this.packFiles(entries);
   }
 
   /**
-   * Pack a directory into a TAR.GZ buffer
+   * Pack a directory into a TAR.GZ buffer (loads all files into memory)
+   * For large directories, use getDirectoryPackStreamGz() instead
    */
   public async packDirectoryToTarGz(
     directoryPath: string,
     compressionLevel?: TCompressionLevel
-  ): Promise<Buffer> {
-    const pack = await this.packDirectory(directoryPath);
-    pack.finalize();
-
-    const gzipTools = new GzipTools();
-    const gzipStream = gzipTools.getCompressionStream(compressionLevel);
-
-    const chunks: Buffer[] = [];
-    return new Promise((resolve, reject) => {
-      pack
-        .pipe(gzipStream)
-        .on('data', (chunk: Buffer) => chunks.push(chunk))
-        .on('end', () => resolve(Buffer.concat(chunks)))
-        .on('error', reject);
-    });
+  ): Promise<Uint8Array> {
+    const tarBuffer = await this.packDirectory(directoryPath);
+    const { gzipSync } = await import('fflate');
+    return gzipSync(new Uint8Array(tarBuffer), { level: compressionLevel ?? 6 });
   }
 
   /**
    * Pack a directory into a TAR.GZ stream
+   * This is now a true streaming implementation
    */
   public async packDirectoryToTarGzStream(
     directoryPath: string,
     compressionLevel?: TCompressionLevel
   ): Promise<plugins.stream.Readable> {
-    const pack = await this.packDirectory(directoryPath);
-    pack.finalize();
-
-    const gzipTools = new GzipTools();
-    const gzipStream = gzipTools.getCompressionStream(compressionLevel);
-
-    return pack.pipe(gzipStream);
-  }
-
-  /**
-   * Pack files into a TAR.GZ buffer
-   */
-  public async packFilesToTarGz(
-    files: IArchiveEntry[],
-    compressionLevel?: TCompressionLevel
-  ): Promise<Buffer> {
-    const tarBuffer = await this.packFiles(files);
-    const gzipTools = new GzipTools();
-    return gzipTools.compress(tarBuffer, compressionLevel);
+    return this.getDirectoryPackStreamGz(directoryPath, compressionLevel);
   }
 }

package/ts/index.ts

@@ -1,15 +1,11 @@
-// Core types and errors
-export * from './interfaces.js';
-export * from './errors.js';
+// Re-export everything from ts_shared (browser-compatible)
+export * from '../ts_shared/index.js';
 
-// Main archive class
+// Node.js-specific: Main archive class with filesystem support
 export * from './classes.smartarchive.js';
 
-// Format-specific tools
-export * from './classes.tartools.js';
-export * from './classes.ziptools.js';
-export * from './classes.gziptools.js';
-export * from './classes.bzip2tools.js';
-
-// Archive analysis
+// Node.js-specific: Archive analysis with SmartArchive integration
 export * from './classes.archiveanalyzer.js';
+
+// Node.js-specific: Extended TarTools with streaming support (overrides shared TarTools)
+export { TarTools, type ITarPackFileOptions } from './classes.tartools.js';

package/ts/plugins.ts

@@ -1,4 +1,4 @@
-// node native scope
+// Node.js native scope
 import * as path from 'node:path';
 import * as stream from 'node:stream';
 import * as fs from 'node:fs';
@@ -30,32 +30,24 @@ export async function listFileTree(dirPath: string, _pattern: string = '**/*'):
   return results;
 }
 
-// @pushrocks scope
-import * as smartfile from '@push.rocks/smartfile';
-import * as smartdelay from '@push.rocks/smartdelay';
+// Re-export browser-compatible plugins from ts_shared
+export * from '../ts_shared/plugins.js';
+
+// Additional Node.js-specific @pushrocks packages
 import * as smartpath from '@push.rocks/smartpath';
-import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartunique from '@push.rocks/smartunique';
-import * as smartstream from '@push.rocks/smartstream';
 import * as smartrx from '@push.rocks/smartrx';
 import * as smarturl from '@push.rocks/smarturl';
 
 export {
-  smartfile,
-  smartdelay,
   smartpath,
-  smartpromise,
   smartrequest,
   smartunique,
-  smartstream,
   smartrx,
   smarturl,
 };
 
-// third party scope
-import * as fileType from 'file-type';
-import * as fflate from 'fflate';
-import tarStream from 'tar-stream';
-
-export { fileType, fflate, tarStream };
+// Node.js-specific: tar-stream for true streaming TAR support
+import * as tarStream from 'tar-stream';
+export { tarStream };

package/{ts → ts_shared}/bzip2/bititerator.ts

@@ -6,7 +6,7 @@ const BITMASK = [0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff] as const;
  * Creates a bit reader function for BZIP2 decompression.
  * Takes a buffer iterator as input and returns a function that reads bits.
  */
-export function bitIterator(nextBuffer: () => Buffer): IBitReader {
+export function bitIterator(nextBuffer: () => Uint8Array): IBitReader {
   let bit = 0;
   let byte = 0;
   let bytes = nextBuffer();

package/{ts → ts_shared}/bzip2/bzip2.ts

@@ -71,7 +71,7 @@ export class Bzip2 {
   /**
    * Create a bit reader from a byte array
    */
-  array(bytes: Uint8Array | Buffer): (n: number) => number {
+  array(bytes: Uint8Array): (n: number) => number {
     let bit = 0;
     let byte = 0;
     const BITMASK = [0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff];
@@ -99,7 +99,7 @@ export class Bzip2 {
   /**
    * Simple decompression from a buffer
    */
-  simple(srcbuffer: Uint8Array | Buffer, stream: (byte: number) => void): void {
+  simple(srcbuffer: Uint8Array, stream: (byte: number) => void): void {
     const bits = this.array(srcbuffer);
     const size = this.header(bits as IBitReader);
     let ret: number | null = 0;