@push.rocks/smartarchive 5.1.0 → 5.2.1

package/dist_ts_shared/classes.bzip2tools.d.ts

@@ -0,0 +1,10 @@
+import * as plugins from './plugins.js';
+/**
+ * BZIP2 decompression utilities (browser-compatible)
+ */
+export declare class Bzip2Tools {
+    /**
+     * Get a streaming decompression transform
+     */
+    getDecompressionStream(): plugins.smartstream.SmartDuplex<Uint8Array, Uint8Array>;
+}

package/dist_ts_shared/classes.bzip2tools.js

@@ -0,0 +1,14 @@
+import * as plugins from './plugins.js';
+import { unbzip2Stream } from './bzip2/index.js';
+/**
+ * BZIP2 decompression utilities (browser-compatible)
+ */
+export class Bzip2Tools {
+    /**
+     * Get a streaming decompression transform
+     */
+    getDecompressionStream() {
+        return unbzip2Stream();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5iemlwMnRvb2xzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfc2hhcmVkL2NsYXNzZXMuYnppcDJ0b29scy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFakQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sVUFBVTtJQUNyQjs7T0FFRztJQUNILHNCQUFzQjtRQUNwQixPQUFPLGFBQWEsRUFBRSxDQUFDO0lBQ3pCLENBQUM7Q0FDRiJ9

package/dist_ts_shared/classes.gziptools.d.ts

@@ -0,0 +1,26 @@
+import type { TCompressionLevel } from './interfaces.js';
+/**
+ * GZIP compression and decompression utilities (browser-compatible)
+ */
+export declare class GzipTools {
+    /**
+     * Compress data synchronously
+     */
+    compressSync(data: Uint8Array, level?: TCompressionLevel): Uint8Array;
+    /**
+     * Decompress data synchronously
+     */
+    decompressSync(data: Uint8Array): Uint8Array;
+    /**
+     * Compress data asynchronously
+     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
+     * which have issues in Deno)
+     */
+    compress(data: Uint8Array, level?: TCompressionLevel): Promise<Uint8Array>;
+    /**
+     * Decompress data asynchronously
+     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
+     * which have issues in Deno)
+     */
+    decompress(data: Uint8Array): Promise<Uint8Array>;
+}

package/dist_ts_shared/classes.gziptools.js

@@ -0,0 +1,38 @@
+import * as plugins from './plugins.js';
+/**
+ * GZIP compression and decompression utilities (browser-compatible)
+ */
+export class GzipTools {
+    /**
+     * Compress data synchronously
+     */
+    compressSync(data, level) {
+        const options = level !== undefined ? { level } : undefined;
+        return plugins.fflate.gzipSync(data, options);
+    }
+    /**
+     * Decompress data synchronously
+     */
+    decompressSync(data) {
+        return plugins.fflate.gunzipSync(data);
+    }
+    /**
+     * Compress data asynchronously
+     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
+     * which have issues in Deno)
+     */
+    async compress(data, level) {
+        // Use sync version wrapped in Promise for cross-runtime compatibility
+        return this.compressSync(data, level);
+    }
+    /**
+     * Decompress data asynchronously
+     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
+     * which have issues in Deno)
+     */
+    async decompress(data) {
+        // Use sync version wrapped in Promise for cross-runtime compatibility
+        return this.decompressSync(data);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5nemlwdG9vbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19zaGFyZWQvY2xhc3Nlcy5nemlwdG9vbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFHeEM7O0dBRUc7QUFDSCxNQUFNLE9BQU8sU0FBUztJQUNwQjs7T0FFRztJQUNJLFlBQVksQ0FBQyxJQUFnQixFQUFFLEtBQXlCO1FBQzdELE1BQU0sT0FBTyxHQUFHLEtBQUssS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztRQUM1RCxPQUFPLE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNoRCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxjQUFjLENBQUMsSUFBZ0I7UUFDcEMsT0FBTyxPQUFPLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN6QyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLEtBQUssQ0FBQyxRQUFRLENBQUMsSUFBZ0IsRUFBRSxLQUF5QjtRQUMvRCxzRUFBc0U7UUFDdEUsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztJQUN4QyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLEtBQUssQ0FBQyxVQUFVLENBQUMsSUFBZ0I7UUFDdEMsc0VBQXNFO1FBQ3RFLE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNuQyxDQUFDO0NBQ0YifQ==

package/dist_ts_shared/classes.tartools.d.ts

@@ -0,0 +1,30 @@
+import type { IArchiveEntry, TCompressionLevel } from './interfaces.js';
+/**
+ * TAR archive creation and extraction utilities using modern-tar (browser-compatible)
+ */
+export declare class TarTools {
+    /**
+     * Pack files into a TAR buffer
+     */
+    packFiles(files: IArchiveEntry[]): Promise<Uint8Array>;
+    /**
+     * Extract a TAR buffer to an array of entries
+     */
+    extractTar(data: Uint8Array): Promise<Array<{
+        path: string;
+        content: Uint8Array;
+        isDirectory: boolean;
+    }>>;
+    /**
+     * Pack files into a TAR.GZ buffer
+     */
+    packFilesToTarGz(files: IArchiveEntry[], compressionLevel?: TCompressionLevel): Promise<Uint8Array>;
+    /**
+     * Extract a TAR.GZ buffer to an array of entries
+     */
+    extractTarGz(data: Uint8Array): Promise<Array<{
+        path: string;
+        content: Uint8Array;
+        isDirectory: boolean;
+    }>>;
+}

package/dist_ts_shared/classes.tartools.js

@@ -0,0 +1,78 @@
+import * as plugins from './plugins.js';
+import { GzipTools } from './classes.gziptools.js';
+/**
+ * TAR archive creation and extraction utilities using modern-tar (browser-compatible)
+ */
+export class TarTools {
+    /**
+     * Pack files into a TAR buffer
+     */
+    async packFiles(files) {
+        const entries = [];
+        for (const file of files) {
+            let data;
+            if (typeof file.content === 'string') {
+                data = new TextEncoder().encode(file.content);
+            }
+            else if (file.content instanceof Uint8Array) {
+                data = file.content;
+            }
+            else if (file.content instanceof plugins.smartfile.SmartFile) {
+                data = new Uint8Array(file.content.contents);
+            }
+            else if (file.content instanceof plugins.smartfile.StreamFile) {
+                const buffer = await file.content.getContentAsBuffer();
+                data = new Uint8Array(buffer);
+            }
+            else {
+                throw new Error('Unsupported content type for TAR entry');
+            }
+            entries.push({
+                header: {
+                    name: file.archivePath,
+                    size: data.length,
+                    type: 'file',
+                    mode: file.mode,
+                    mtime: file.mtime,
+                },
+                body: data,
+            });
+        }
+        return plugins.modernTar.packTar(entries);
+    }
+    /**
+     * Extract a TAR buffer to an array of entries
+     */
+    async extractTar(data) {
+        const entries = await plugins.modernTar.unpackTar(data);
+        const result = [];
+        for (const entry of entries) {
+            const isDirectory = entry.header.type === 'directory' || entry.header.name.endsWith('/');
+            // modern-tar uses 'data' property, not 'body'
+            const content = entry.data ?? new Uint8Array(0);
+            result.push({
+                path: entry.header.name,
+                content,
+                isDirectory,
+            });
+        }
+        return result;
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Extract a TAR.GZ buffer to an array of entries
+     */
+    async extractTarGz(data) {
+        const gzipTools = new GzipTools();
+        const tarBuffer = await gzipTools.decompress(data);
+        return this.extractTar(tarBuffer);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_shared/classes.ziptools.d.ts

@@ -0,0 +1,31 @@
+import * as plugins from './plugins.js';
+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<Uint8Array, plugins.smartfile.StreamFile> {
+    private streamtools;
+    private unzipper;
+    constructor();
+}
+/**
+ * ZIP compression and decompression utilities
+ */
+export declare class ZipTools {
+    /**
+     * 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<Uint8Array>;
+    /**
+     * Extract a ZIP buffer to an array of entries
+     */
+    extractZip(data: Uint8Array): Promise<Array<{
+        path: string;
+        content: Uint8Array;
+    }>>;
+}

package/dist_ts_shared/classes.ziptools.js

@@ -0,0 +1,103 @@
+import * as plugins from './plugins.js';
+/**
+ * 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);
+                const chunk = chunkArg instanceof Uint8Array ? chunkArg : new Uint8Array(chunkArg);
+                this.unzipper.push(chunk, false);
+                return null;
+            },
+            finalFunction: async () => {
+                this.unzipper.push(new Uint8Array(0), 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) => {
+                if (resultBuffer) {
+                    const combined = new Uint8Array(resultBuffer.length + dat.length);
+                    combined.set(resultBuffer);
+                    combined.set(dat, resultBuffer.length);
+                    resultBuffer = combined;
+                }
+                else {
+                    resultBuffer = new Uint8Array(dat);
+                }
+                if (final) {
+                    const streamFile = plugins.smartfile.StreamFile.fromBuffer(Buffer.from(resultBuffer));
+                    streamFile.relativeFilePath = fileArg.name;
+                    this.streamtools.push(streamFile);
+                }
+            };
+            fileArg.start();
+        });
+        this.unzipper.register(plugins.fflate.UnzipInflate);
+    }
+}
+/**
+ * ZIP compression and decompression utilities
+ */
+export class ZipTools {
+    /**
+     * Get a streaming decompression transform for extracting ZIP archives
+     */
+    getDecompressionStream() {
+        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 (entry.content instanceof Uint8Array) {
+                data = 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 {
+                throw new Error('Unsupported content type for ZIP entry');
+            }
+            if (compressionLevel !== undefined) {
+                filesObj[entry.archivePath] = [data, { level: compressionLevel }];
+            }
+            else {
+                filesObj[entry.archivePath] = data;
+            }
+        }
+        // Use sync version for Deno compatibility (fflate async uses Web Workers)
+        const result = plugins.fflate.zipSync(filesObj);
+        return result;
+    }
+    /**
+     * Extract a ZIP buffer to an array of entries
+     */
+    async extractZip(data) {
+        // Use sync version for Deno compatibility (fflate async uses Web Workers)
+        const result = plugins.fflate.unzipSync(data);
+        const entries = [];
+        for (const [path, content] of Object.entries(result)) {
+            entries.push({ path, content });
+        }
+        return entries;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_shared/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_shared/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfc2hhcmVkL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sT0FBTyxpQkFBa0IsU0FBUSxLQUFLO0lBRzFDLFlBQVksT0FBZSxFQUFFLElBQVk7UUFDdkMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxtQkFBbUIsQ0FBQztRQUNoQyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQiwrREFBK0Q7UUFDL0QsSUFBSSxLQUFLLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztZQUM1QixLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUNsRCxDQUFDO0lBQ0gsQ0FBQztDQUNGO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sVUFBVyxTQUFRLGlCQUFpQjtJQUMvQyxZQUFZLE9BQWUsRUFBRSxPQUFlLGFBQWE7UUFDdkQsS0FBSyxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQztRQUNyQixJQUFJLENBQUMsSUFBSSxHQUFHLFlBQVksQ0FBQztJQUMzQixDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxrQkFBbUIsU0FBUSxpQkFBaUI7SUFDdkQsWUFBWSxPQUFlO1FBQ3pCLEtBQUssQ0FBQyxPQUFPLEVBQUUsc0JBQXNCLENBQUMsQ0FBQztRQUN2QyxJQUFJLENBQUMsSUFBSSxHQUFHLG9CQUFvQixDQUFDO0lBQ25DLENBQUM7Q0FDRjtBQUVEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFdBQVksU0FBUSxpQkFBaUI7SUFDaEQsWUFBWSxPQUFlO1FBQ3pCLEtBQUssQ0FBQyxPQUFPLEVBQUUsY0FBYyxDQUFDLENBQUM7UUFDL0IsSUFBSSxDQUFDLElBQUksR0FBRyxhQUFhLENBQUM7SUFDNUIsQ0FBQztDQUNGO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRztJQUMvQixlQUFlLEVBQUUsZ0JBQWdCO0lBQ2pDLGVBQWUsRUFBRSx1QkFBdUI7SUFDeEMsWUFBWSxFQUFFLG9CQUFvQjtJQUNsQyxrQkFBa0IsRUFBRSxxQkFBcUI7SUFDekMsZUFBZSxFQUFFLHVCQUF1QjtJQUN4QyxlQUFlLEVBQUUsdUJBQXVCO0lBQ3hDLGdCQUFnQixFQUFFLHdCQUF3QjtJQUMxQyxnQkFBZ0IsRUFBRSx3QkFBd0I7SUFDMUMsYUFBYSxFQUFFLHFCQUFxQjtDQUM1QixDQUFDO0FBSVg7O0dBRUc7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUFDLE9BQWUsRUFBRSxJQUFxQjtJQUNwRSxNQUFNLElBQUksVUFBVSxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQztBQUN0QyxDQUFDIn0=

package/dist_ts_shared/index.d.ts

@@ -0,0 +1,8 @@
+export * from './interfaces.js';
+export * from './errors.js';
+export { ZipTools, ZipDecompressionTransform } from './classes.ziptools.js';
+export { GzipTools } from './classes.gziptools.js';
+export { TarTools } from './classes.tartools.js';
+export { Bzip2Tools } from './classes.bzip2tools.js';
+export { unbzip2Stream } from './bzip2/index.js';
+export { Bzip2 } from './bzip2/bzip2.js';

package/dist_ts_shared/index.js

@@ -0,0 +1,14 @@
+// ts_shared - Browser-compatible shared code
+// Interfaces and types
+export * from './interfaces.js';
+// Error classes
+export * from './errors.js';
+// Tool classes
+export { ZipTools, ZipDecompressionTransform } from './classes.ziptools.js';
+export { GzipTools } from './classes.gziptools.js';
+export { TarTools } from './classes.tartools.js';
+export { Bzip2Tools } from './classes.bzip2tools.js';
+// BZIP2 internals (for advanced usage)
+export { unbzip2Stream } from './bzip2/index.js';
+export { Bzip2 } from './bzip2/bzip2.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19zaGFyZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsNkNBQTZDO0FBRTdDLHVCQUF1QjtBQUN2QixjQUFjLGlCQUFpQixDQUFDO0FBRWhDLGdCQUFnQjtBQUNoQixjQUFjLGFBQWEsQ0FBQztBQUU1QixlQUFlO0FBQ2YsT0FBTyxFQUFFLFFBQVEsRUFBRSx5QkFBeUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzVFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDakQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRXJELHVDQUF1QztBQUN2QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDakQsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLGtCQUFrQixDQUFDIn0=

package/dist_ts_shared/interfaces.d.ts

@@ -0,0 +1,129 @@
+import type { SmartFile, StreamFile } from '@push.rocks/smartfile';
+/**
+ * Supported archive formats
+ */
+export type TArchiveFormat = 'tar' | 'tar.gz' | 'tgz' | 'zip' | 'gz' | 'bz2';
+/**
+ * Compression level (0 = no compression, 9 = maximum compression)
+ */
+export type TCompressionLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+/**
+ * Supported MIME types for archive detection
+ */
+export type TSupportedMime = 'application/gzip' | 'application/zip' | 'application/x-bzip2' | 'application/x-tar' | undefined;
+/**
+ * Entry to add to an archive during creation (browser-compatible)
+ */
+export interface IArchiveEntry {
+    /** Path within the archive */
+    archivePath: string;
+    /** Content: string, Buffer/Uint8Array, SmartFile, or StreamFile */
+    content: string | Uint8Array | SmartFile | StreamFile;
+    /** Optional size hint for streams (improves performance) */
+    size?: number;
+    /** Optional file mode/permissions */
+    mode?: number;
+    /** Optional modification time */
+    mtime?: Date;
+}
+/**
+ * Options for creating archives
+ */
+export interface IArchiveCreationOptions {
+    /** Target archive format */
+    format: TArchiveFormat;
+    /** Compression level (0-9, default depends on format) */
+    compressionLevel?: TCompressionLevel;
+    /** Base path to strip from file paths in archive */
+    basePath?: string;
+}
+/**
+ * Options for extracting archives
+ */
+export interface IArchiveExtractionOptions {
+    /** Target directory for extraction */
+    targetDir: string;
+    /** Optional filename for single-file archives (gz, bz2) */
+    fileName?: string;
+    /** Number of leading path components to strip */
+    stripComponents?: number;
+    /** Filter function to select which entries to extract */
+    filter?: (entry: IArchiveEntryInfo) => boolean;
+    /** Whether to overwrite existing files */
+    overwrite?: boolean;
+}
+/**
+ * Information about an archive entry
+ */
+export interface IArchiveEntryInfo {
+    /** Path of the entry within the archive */
+    path: string;
+    /** Size in bytes */
+    size: number;
+    /** Whether this entry is a directory */
+    isDirectory: boolean;
+    /** Whether this entry is a file */
+    isFile: boolean;
+    /** Modification time */
+    mtime?: Date;
+    /** File mode/permissions */
+    mode?: number;
+}
+/**
+ * Result of archive analysis
+ */
+export interface IArchiveInfo {
+    /** Detected archive format */
+    format: TArchiveFormat | null;
+    /** Whether the archive is compressed */
+    isCompressed: boolean;
+    /** Whether this is a recognized archive format */
+    isArchive: boolean;
+    /** List of entries (if available without full extraction) */
+    entries?: IArchiveEntryInfo[];
+}
+/**
+ * Options for adding a file to a TAR pack stream
+ */
+export interface IAddFileOptions {
+    /** Filename within the archive */
+    fileName?: string;
+    /** File content */
+    content?: string | Uint8Array | SmartFile | StreamFile;
+    /** Size in bytes (required for streams) */
+    byteLength?: number;
+}
+/**
+ * Bit reader interface for BZIP2 decompression
+ */
+export interface IBitReader {
+    (n: number | null): number | void;
+    bytesRead: number;
+}
+/**
+ * Huffman group for BZIP2 decompression
+ */
+export interface IHuffmanGroup {
+    permute: Int32Array;
+    limit: Int32Array;
+    base: Int32Array;
+    minLen: number;
+    maxLen: number;
+}
+/**
+ * Entry filter predicate for fluent API
+ */
+export type TEntryFilter = (entry: IArchiveEntryInfo) => boolean;
+/**
+ * TAR entry for modern-tar compatibility
+ */
+export interface ITarEntry {
+    header: {
+        name: string;
+        size: number;
+        type?: 'file' | 'directory';
+        mode?: number;
+        mtime?: Date;
+    };
+    body: string | Uint8Array;
+}

package/dist_ts_shared/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3NoYXJlZC9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts_shared/plugins.d.ts

@@ -0,0 +1,9 @@
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartstream from '@push.rocks/smartstream';
+import * as smartfile from '@push.rocks/smartfile';
+export { smartdelay, smartpromise, smartstream, smartfile, };
+import * as fileType from 'file-type';
+import * as fflate from 'fflate';
+import * as modernTar from 'modern-tar';
+export { fileType, fflate, modernTar };

package/dist_ts_shared/plugins.js

@@ -0,0 +1,14 @@
+// Browser-compatible plugins for ts_shared
+// NO Node.js imports allowed here
+// @push.rocks scope (browser-compatible)
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartstream from '@push.rocks/smartstream';
+import * as smartfile from '@push.rocks/smartfile';
+export { smartdelay, smartpromise, smartstream, smartfile, };
+// third party scope (browser-compatible)
+import * as fileType from 'file-type';
+import * as fflate from 'fflate';
+import * as modernTar from 'modern-tar';
+export { fileType, fflate, modernTar };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3NoYXJlZC9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJDQUEyQztBQUMzQyxrQ0FBa0M7QUFFbEMseUNBQXlDO0FBQ3pDLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUNMLFVBQVUsRUFDVixZQUFZLEVBQ1osV0FBVyxFQUNYLFNBQVMsR0FDVixDQUFDO0FBRUYseUNBQXlDO0FBQ3pDLE9BQU8sS0FBSyxRQUFRLE1BQU0sV0FBVyxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxTQUFTLE1BQU0sWUFBWSxDQUFDO0FBRXhDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxDQUFDIn0=

package/dist_ts_web/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts_web/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartarchive',
+    version: '5.1.0',
+    description: 'A library for working with archive files, providing utilities for compressing and decompressing data.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsMEJBQTBCO0lBQ2hDLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSx1R0FBdUc7Q0FDckgsQ0FBQSJ9