@push.rocks/smartarchive 4.2.3 → 5.0.0

package/dist_ts/classes.tartools.js

@@ -1,8 +1,12 @@
 import * as plugins from './plugins.js';
+import { GzipTools } from './classes.gziptools.js';
+/**
+ * TAR archive creation and extraction utilities
+ */
 export class TarTools {
-    // INSTANCE
-    constructor() { }
-    // packing
+    /**
+     * Add a file to a TAR pack stream
+     */
     async addFileToPack(pack, optionsArg) {
         return new Promise(async (resolve, reject) => {
             let fileName = null;
@@ -13,15 +17,16 @@ export class TarTools {
                 fileName = optionsArg.content.relative;
             }
             else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
-                fileName = optionsArg.content
-                    .relativeFilePath;
+                fileName = optionsArg.content.relativeFilePath;
             }
             else if (optionsArg.filePath) {
                 fileName = optionsArg.filePath;
             }
-            /**
-             * contentByteLength is used to set the size of the entry in the tar file
-             */
+            if (!fileName) {
+                reject(new Error('No filename specified for TAR entry'));
+                return;
+            }
+            // Determine content byte length
             let contentByteLength;
             if (optionsArg.byteLength) {
                 contentByteLength = optionsArg.byteLength;
@@ -33,44 +38,42 @@ export class TarTools {
                 contentByteLength = optionsArg.content.length;
             }
             else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
-                contentByteLength = await optionsArg.content.getSize(); // assuming SmartFile has getSize method
+                contentByteLength = await optionsArg.content.getSize();
             }
             else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
-                contentByteLength = await optionsArg.content.getSize(); // assuming StreamFile has getSize method
-            }
-            else if (optionsArg.content instanceof plugins.smartstream.stream.Readable) {
-                console.warn('@push.rocks/smartarchive: When streaming, it is recommended to provide byteLength, if known.');
+                contentByteLength = await optionsArg.content.getSize();
             }
             else if (optionsArg.filePath) {
-                const fileStat = await plugins.smartfile.fs.stat(optionsArg.filePath);
+                const fileStat = await plugins.fsPromises.stat(optionsArg.filePath);
                 contentByteLength = fileStat.size;
             }
-            /**
-             * here we try to harmonize all kind of entries towards a readable stream
-             */
+            // Convert all content types to Readable stream
             let content;
             if (Buffer.isBuffer(optionsArg.content)) {
-                content = plugins.smartstream.stream.Readable.from(optionsArg.content);
+                content = plugins.stream.Readable.from(optionsArg.content);
             }
             else if (typeof optionsArg.content === 'string') {
-                content = plugins.smartstream.stream.Readable.from(Buffer.from(optionsArg.content));
+                content = plugins.stream.Readable.from(Buffer.from(optionsArg.content));
             }
             else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
-                content = plugins.smartstream.stream.Readable.from(optionsArg.content.contents);
+                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.smartstream.stream.Readable) {
+            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;
+            }
             const entry = pack.entry({
                 name: fileName,
-                ...(contentByteLength
-                    ? {
-                        size: contentByteLength,
-                    }
-                    : null),
+                ...(contentByteLength !== undefined ? { size: contentByteLength } : {}),
             }, (err) => {
                 if (err) {
                     reject(err);
@@ -80,35 +83,93 @@ export class TarTools {
                 }
             });
             content.pipe(entry);
-            resolve();
+            // Note: resolve() is called in the callback above when pipe completes
         });
     }
     /**
-     * packs a directory from disk into a tar stream
-     * @param directoryPath
+     * Pack a directory into a TAR stream
      */
     async packDirectory(directoryPath) {
-        const fileTree = await plugins.smartfile.fs.listFileTree(directoryPath, '**/*');
+        const fileTree = await plugins.listFileTree(directoryPath, '**/*');
         const pack = await this.getPackStream();
         for (const filePath of fileTree) {
             const absolutePath = plugins.path.join(directoryPath, filePath);
-            const fileStat = await plugins.smartfile.fs.stat(absolutePath);
+            const fileStat = await plugins.fsPromises.stat(absolutePath);
             await this.addFileToPack(pack, {
                 byteLength: fileStat.size,
                 filePath: absolutePath,
                 fileName: filePath,
-                content: plugins.smartfile.fsStream.createReadStream(absolutePath),
+                content: plugins.fs.createReadStream(absolutePath),
             });
         }
         return pack;
     }
+    /**
+     * Get a new TAR pack stream
+     */
     async getPackStream() {
-        const pack = plugins.tarStream.pack();
-        return pack;
+        return plugins.tarStream.pack();
     }
-    // extracting
+    /**
+     * Get a TAR extraction stream
+     */
     getDecompressionStream() {
         return plugins.tarStream.extract();
     }
+    /**
+     * Pack files into a TAR buffer
+     */
+    async packFiles(files) {
+        const pack = await this.getPackStream();
+        for (const file of files) {
+            await this.addFileToPack(pack, {
+                fileName: file.archivePath,
+                content: file.content,
+                byteLength: file.size,
+            });
+        }
+        pack.finalize();
+        const chunks = [];
+        return new Promise((resolve, reject) => {
+            pack.on('data', (chunk) => chunks.push(chunk));
+            pack.on('end', () => resolve(Buffer.concat(chunks)));
+            pack.on('error', reject);
+        });
+    }
+    /**
+     * Pack a directory into a TAR.GZ buffer
+     */
+    async packDirectoryToTarGz(directoryPath, compressionLevel) {
+        const pack = await this.packDirectory(directoryPath);
+        pack.finalize();
+        const gzipTools = new GzipTools();
+        const gzipStream = gzipTools.getCompressionStream(compressionLevel);
+        const chunks = [];
+        return new Promise((resolve, reject) => {
+            pack
+                .pipe(gzipStream)
+                .on('data', (chunk) => chunks.push(chunk))
+                .on('end', () => resolve(Buffer.concat(chunks)))
+                .on('error', reject);
+        });
+    }
+    /**
+     * Pack a directory into a TAR.GZ stream
+     */
+    async packDirectoryToTarGzStream(directoryPath, compressionLevel) {
+        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
+     */
+    async packFilesToTarGz(files, compressionLevel) {
+        const tarBuffer = await this.packFiles(files);
+        const gzipTools = new GzipTools();
+        return gzipTools.compress(tarBuffer, compressionLevel);
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.ziptools.d.ts

@@ -1,21 +1,56 @@
 import * as plugins from './plugins.js';
-declare class DecompressZipTransform extends plugins.smartstream
-    .SmartDuplex<ArrayBufferLike> {
+import type { IArchiveEntry, TCompressionLevel } from './interfaces.js';
+/**
+ * Transform stream for ZIP decompression using fflate
+ * Emits StreamFile objects for each file in the archive
+ */
+export declare class ZipDecompressionTransform extends plugins.smartstream.SmartDuplex<Buffer, plugins.smartfile.StreamFile> {
     private streamtools;
     private unzipper;
     constructor();
 }
-export declare class CompressZipTransform extends plugins.stream.Transform {
-    files: {
-        [fileName: string]: Uint8Array;
-    };
+/**
+ * Streaming ZIP compression using fflate
+ * Allows adding multiple entries before finalizing
+ */
+export declare class ZipCompressionStream extends plugins.stream.Duplex {
+    private files;
+    private finalized;
     constructor();
-    _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback): void;
-    _flush(callback: plugins.stream.TransformCallback): void;
+    /**
+     * Add a file entry to the ZIP archive
+     */
+    addEntry(fileName: string, content: Buffer | plugins.stream.Readable, options?: {
+        compressionLevel?: TCompressionLevel;
+    }): Promise<void>;
+    /**
+     * Finalize the ZIP archive and emit the compressed data
+     */
+    finalize(): Promise<void>;
+    _read(): void;
+    _write(_chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
 }
+/**
+ * ZIP compression and decompression utilities
+ */
 export declare class ZipTools {
-    constructor();
-    getCompressionStream(): CompressZipTransform;
-    getDecompressionStream(): DecompressZipTransform;
+    /**
+     * Get a streaming compression object for creating ZIP archives
+     */
+    getCompressionStream(): ZipCompressionStream;
+    /**
+     * Get a streaming decompression transform for extracting ZIP archives
+     */
+    getDecompressionStream(): ZipDecompressionTransform;
+    /**
+     * Create a ZIP archive from an array of entries
+     */
+    createZip(entries: IArchiveEntry[], compressionLevel?: TCompressionLevel): Promise<Buffer>;
+    /**
+     * Extract a ZIP buffer to an array of entries
+     */
+    extractZip(data: Buffer): Promise<Array<{
+        path: string;
+        content: Buffer;
+    }>>;
 }
-export {};

package/dist_ts/classes.ziptools.js

@@ -1,22 +1,27 @@
 import * as plugins from './plugins.js';
-class DecompressZipTransform extends plugins.smartstream
-    .SmartDuplex {
+/**
+ * Transform stream for ZIP decompression using fflate
+ * Emits StreamFile objects for each file in the archive
+ */
+export class ZipDecompressionTransform extends plugins.smartstream.SmartDuplex {
     constructor() {
         super({
             objectMode: true,
             writeFunction: async (chunkArg, streamtoolsArg) => {
                 this.streamtools ? null : (this.streamtools = streamtoolsArg);
                 this.unzipper.push(Buffer.isBuffer(chunkArg) ? chunkArg : Buffer.from(chunkArg), false);
+                return null;
             },
             finalFunction: async () => {
                 this.unzipper.push(Buffer.from(''), true);
                 await plugins.smartdelay.delayFor(0);
                 await this.streamtools.push(null);
+                return null;
             },
         });
         this.unzipper = new plugins.fflate.Unzip(async (fileArg) => {
             let resultBuffer;
-            fileArg.ondata = async (flateError, dat, final) => {
+            fileArg.ondata = async (_flateError, dat, final) => {
                 resultBuffer
                     ? (resultBuffer = Buffer.concat([resultBuffer, Buffer.from(dat)]))
                     : (resultBuffer = Buffer.from(dat));
@@ -31,36 +36,150 @@ class DecompressZipTransform extends plugins.smartstream
         this.unzipper.register(plugins.fflate.UnzipInflate);
     }
 }
-// This class wraps fflate's zip in a Node.js Transform stream for compression
-export class CompressZipTransform extends plugins.stream.Transform {
+/**
+ * Streaming ZIP compression using fflate
+ * Allows adding multiple entries before finalizing
+ */
+export class ZipCompressionStream extends plugins.stream.Duplex {
     constructor() {
         super();
-        this.files = {};
+        this.files = new Map();
+        this.finalized = false;
     }
-    _transform(chunk, encoding, callback) {
-        // Simple example: storing chunks in memory before finalizing ZIP in _flush
-        this.files['file.txt'] = new Uint8Array(chunk);
-        callback();
-    }
-    _flush(callback) {
-        plugins.fflate.zip(this.files, (err, zipped) => {
-            if (err) {
-                callback(err);
-            }
-            else {
-                this.push(Buffer.from(zipped));
-                callback();
+    /**
+     * Add a file entry to the ZIP archive
+     */
+    async addEntry(fileName, content, options) {
+        if (this.finalized) {
+            throw new Error('Cannot add entries to a finalized ZIP archive');
+        }
+        let data;
+        if (Buffer.isBuffer(content)) {
+            data = content;
+        }
+        else {
+            // Collect stream to buffer
+            const chunks = [];
+            for await (const chunk of content) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
             }
+            data = Buffer.concat(chunks);
+        }
+        this.files.set(fileName, {
+            data: new Uint8Array(data),
+            options: options?.compressionLevel !== undefined ? { level: options.compressionLevel } : undefined,
+        });
+    }
+    /**
+     * Finalize the ZIP archive and emit the compressed data
+     */
+    async finalize() {
+        if (this.finalized) {
+            return;
+        }
+        this.finalized = true;
+        const filesObj = {};
+        for (const [name, { data, options }] of this.files) {
+            filesObj[name] = options ? [data, options] : data;
+        }
+        return new Promise((resolve, reject) => {
+            plugins.fflate.zip(filesObj, (err, result) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    this.push(Buffer.from(result));
+                    this.push(null);
+                    resolve();
+                }
+            });
         });
     }
+    _read() {
+        // No-op: data is pushed when finalize() is called
+    }
+    _write(_chunk, _encoding, callback) {
+        // Not used for ZIP creation - use addEntry() instead
+        callback(new Error('Use addEntry() to add files to the ZIP archive'));
+    }
 }
+/**
+ * ZIP compression and decompression utilities
+ */
 export class ZipTools {
-    constructor() { }
+    /**
+     * Get a streaming compression object for creating ZIP archives
+     */
     getCompressionStream() {
-        return new CompressZipTransform();
+        return new ZipCompressionStream();
     }
+    /**
+     * Get a streaming decompression transform for extracting ZIP archives
+     */
     getDecompressionStream() {
-        return new DecompressZipTransform();
+        return new ZipDecompressionTransform();
+    }
+    /**
+     * Create a ZIP archive from an array of entries
+     */
+    async createZip(entries, compressionLevel) {
+        const filesObj = {};
+        for (const entry of entries) {
+            let data;
+            if (typeof entry.content === 'string') {
+                data = new TextEncoder().encode(entry.content);
+            }
+            else if (Buffer.isBuffer(entry.content)) {
+                data = new Uint8Array(entry.content);
+            }
+            else if (entry.content instanceof plugins.smartfile.SmartFile) {
+                data = new Uint8Array(entry.content.contents);
+            }
+            else if (entry.content instanceof plugins.smartfile.StreamFile) {
+                const buffer = await entry.content.getContentAsBuffer();
+                data = new Uint8Array(buffer);
+            }
+            else {
+                // Readable stream
+                const chunks = [];
+                for await (const chunk of entry.content) {
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                }
+                data = new Uint8Array(Buffer.concat(chunks));
+            }
+            if (compressionLevel !== undefined) {
+                filesObj[entry.archivePath] = [data, { level: compressionLevel }];
+            }
+            else {
+                filesObj[entry.archivePath] = data;
+            }
+        }
+        return new Promise((resolve, reject) => {
+            plugins.fflate.zip(filesObj, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(Buffer.from(result));
+            });
+        });
+    }
+    /**
+     * Extract a ZIP buffer to an array of entries
+     */
+    async extractZip(data) {
+        return new Promise((resolve, reject) => {
+            plugins.fflate.unzip(data, (err, result) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                const entries = [];
+                for (const [path, content] of Object.entries(result)) {
+                    entries.push({ path, content: Buffer.from(content) });
+                }
+                resolve(entries);
+            });
+        });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/errors.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Base error class for smartarchive
+ */
+export declare class SmartArchiveError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/**
+ * BZIP2-specific decompression errors
+ */
+export declare class Bzip2Error extends SmartArchiveError {
+    constructor(message: string, code?: string);
+}
+/**
+ * Archive format detection errors
+ */
+export declare class ArchiveFormatError extends SmartArchiveError {
+    constructor(message: string);
+}
+/**
+ * Stream processing errors
+ */
+export declare class StreamError extends SmartArchiveError {
+    constructor(message: string);
+}
+/**
+ * BZIP2 error codes for programmatic error handling
+ */
+export declare const BZIP2_ERROR_CODES: {
+    readonly NO_MAGIC_NUMBER: "BZIP2_NO_MAGIC";
+    readonly INVALID_ARCHIVE: "BZIP2_INVALID_ARCHIVE";
+    readonly CRC_MISMATCH: "BZIP2_CRC_MISMATCH";
+    readonly INVALID_BLOCK_DATA: "BZIP2_INVALID_BLOCK";
+    readonly BUFFER_OVERFLOW: "BZIP2_BUFFER_OVERFLOW";
+    readonly INVALID_HUFFMAN: "BZIP2_INVALID_HUFFMAN";
+    readonly INVALID_SELECTOR: "BZIP2_INVALID_SELECTOR";
+    readonly INVALID_POSITION: "BZIP2_INVALID_POSITION";
+    readonly PREMATURE_END: "BZIP2_PREMATURE_END";
+};
+export type TBzip2ErrorCode = typeof BZIP2_ERROR_CODES[keyof typeof BZIP2_ERROR_CODES];
+/**
+ * Throw a BZIP2 error with a specific code
+ */
+export declare function throwBzip2Error(message: string, code: TBzip2ErrorCode): never;

package/dist_ts/errors.js

@@ -0,0 +1,62 @@
+/**
+ * Base error class for smartarchive
+ */
+export class SmartArchiveError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = 'SmartArchiveError';
+        this.code = code;
+        // Maintains proper stack trace for where error was thrown (V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+/**
+ * BZIP2-specific decompression errors
+ */
+export class Bzip2Error extends SmartArchiveError {
+    constructor(message, code = 'BZIP2_ERROR') {
+        super(message, code);
+        this.name = 'Bzip2Error';
+    }
+}
+/**
+ * Archive format detection errors
+ */
+export class ArchiveFormatError extends SmartArchiveError {
+    constructor(message) {
+        super(message, 'ARCHIVE_FORMAT_ERROR');
+        this.name = 'ArchiveFormatError';
+    }
+}
+/**
+ * Stream processing errors
+ */
+export class StreamError extends SmartArchiveError {
+    constructor(message) {
+        super(message, 'STREAM_ERROR');
+        this.name = 'StreamError';
+    }
+}
+/**
+ * BZIP2 error codes for programmatic error handling
+ */
+export const BZIP2_ERROR_CODES = {
+    NO_MAGIC_NUMBER: 'BZIP2_NO_MAGIC',
+    INVALID_ARCHIVE: 'BZIP2_INVALID_ARCHIVE',
+    CRC_MISMATCH: 'BZIP2_CRC_MISMATCH',
+    INVALID_BLOCK_DATA: 'BZIP2_INVALID_BLOCK',
+    BUFFER_OVERFLOW: 'BZIP2_BUFFER_OVERFLOW',
+    INVALID_HUFFMAN: 'BZIP2_INVALID_HUFFMAN',
+    INVALID_SELECTOR: 'BZIP2_INVALID_SELECTOR',
+    INVALID_POSITION: 'BZIP2_INVALID_POSITION',
+    PREMATURE_END: 'BZIP2_PREMATURE_END',
+};
+/**
+ * Throw a BZIP2 error with a specific code
+ */
+export function throwBzip2Error(message, code) {
+    throw new Bzip2Error(message, code);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGlCQUFrQixTQUFRLEtBQUs7SUFHMUMsWUFBWSxPQUFlLEVBQUUsSUFBWTtRQUN2QyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLG1CQUFtQixDQUFDO1FBQ2hDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2pCLCtEQUErRDtRQUMvRCxJQUFJLEtBQUssQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1lBQzVCLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ2xELENBQUM7SUFDSCxDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxVQUFXLFNBQVEsaUJBQWlCO0lBQy9DLFlBQVksT0FBZSxFQUFFLE9BQWUsYUFBYTtRQUN2RCxLQUFLLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ3JCLElBQUksQ0FBQyxJQUFJLEdBQUcsWUFBWSxDQUFDO0lBQzNCLENBQUM7Q0FDRjtBQUVEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGtCQUFtQixTQUFRLGlCQUFpQjtJQUN2RCxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLE9BQU8sRUFBRSxzQkFBc0IsQ0FBQyxDQUFDO1FBQ3ZDLElBQUksQ0FBQyxJQUFJLEdBQUcsb0JBQW9CLENBQUM7SUFDbkMsQ0FBQztDQUNGO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sV0FBWSxTQUFRLGlCQUFpQjtJQUNoRCxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLE9BQU8sRUFBRSxjQUFjLENBQUMsQ0FBQztRQUMvQixJQUFJLENBQUMsSUFBSSxHQUFHLGFBQWEsQ0FBQztJQUM1QixDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHO0lBQy9CLGVBQWUsRUFBRSxnQkFBZ0I7SUFDakMsZUFBZSxFQUFFLHVCQUF1QjtJQUN4QyxZQUFZLEVBQUUsb0JBQW9CO0lBQ2xDLGtCQUFrQixFQUFFLHFCQUFxQjtJQUN6QyxlQUFlLEVBQUUsdUJBQXVCO0lBQ3hDLGVBQWUsRUFBRSx1QkFBdUI7SUFDeEMsZ0JBQWdCLEVBQUUsd0JBQXdCO0lBQzFDLGdCQUFnQixFQUFFLHdCQUF3QjtJQUMxQyxhQUFhLEVBQUUscUJBQXFCO0NBQzVCLENBQUM7QUFJWDs7R0FFRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQUMsT0FBZSxFQUFFLElBQXFCO0lBQ3BFLE1BQU0sSUFBSSxVQUFVLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO0FBQ3RDLENBQUMifQ==

package/dist_ts/index.d.ts

@@ -1,4 +1,8 @@
+export * from './interfaces.js';
+export * from './errors.js';
 export * from './classes.smartarchive.js';
 export * from './classes.tartools.js';
 export * from './classes.ziptools.js';
 export * from './classes.gziptools.js';
+export * from './classes.bzip2tools.js';
+export * from './classes.archiveanalyzer.js';

package/dist_ts/index.js

@@ -1,5 +1,13 @@
+// Core types and errors
+export * from './interfaces.js';
+export * from './errors.js';
+// Main archive class
 export * from './classes.smartarchive.js';
+// Format-specific tools
 export * from './classes.tartools.js';
 export * from './classes.ziptools.js';
 export * from './classes.gziptools.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHdCQUF3QixDQUFDIn0=
+export * from './classes.bzip2tools.js';
+// Archive analysis
+export * from './classes.archiveanalyzer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3QkFBd0I7QUFDeEIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGFBQWEsQ0FBQztBQUU1QixxQkFBcUI7QUFDckIsY0FBYywyQkFBMkIsQ0FBQztBQUUxQyx3QkFBd0I7QUFDeEIsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx5QkFBeUIsQ0FBQztBQUV4QyxtQkFBbUI7QUFDbkIsY0FBYyw4QkFBOEIsQ0FBQyJ9