7zip-wrapper 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,639 @@
+import { ExecOptions } from 'child_process';
+import { Readable } from 'stream';
+
+/**
+ * Archive-related types
+ */
+/**
+ * Supported archive formats for reading
+ */
+type ArchiveFormat = '7z' | 'zip' | 'gzip' | 'bzip2' | 'tar' | 'rar' | 'iso' | 'cab' | 'lzma' | 'lzma2' | 'xz' | 'wim' | 'arj' | 'cpio' | 'rpm' | 'deb' | 'vhd' | 'fat' | 'ntfs';
+/**
+ * Archive types for creation
+ */
+type ArchiveType = '7z' | 'zip' | 'gzip' | 'bzip2' | 'tar' | 'xz' | 'wim';
+/**
+ * Archive entry information
+ */
+interface ArchiveEntry {
+    /** File path within archive */
+    path: string;
+    /** Original file size in bytes */
+    size: number;
+    /** Compressed size in bytes */
+    packedSize: number;
+    /** Last modified date */
+    modified: Date;
+    /** File attributes (e.g., 'D' for directory, 'A' for archive) */
+    attributes: string;
+    /** CRC checksum */
+    crc: string;
+    /** Compression method used */
+    method: string;
+    /** Whether entry is a directory */
+    isDirectory: boolean;
+    /** Whether entry is encrypted */
+    encrypted?: boolean;
+    /** Whether entry is a symbolic link */
+    isSymlink?: boolean;
+}
+/**
+ * Archive operation result
+ */
+interface ArchiveResult {
+    /** Whether operation succeeded */
+    success: boolean;
+    /** Full command that was executed */
+    command: string;
+    /** Standard output from 7-Zip */
+    stdout: string;
+    /** Standard error from 7-Zip */
+    stderr: string;
+    /** Exit code (0 = success) */
+    exitCode: number | null;
+}
+/**
+ * List operation result
+ */
+interface ListResult {
+    /** Archive file path */
+    archive: string;
+    /** Total uncompressed size in bytes */
+    size: number;
+    /** Total compressed size in bytes */
+    packedSize: number;
+    /** Number of files in archive */
+    fileCount: number;
+    /** Number of directories in archive */
+    dirCount: number;
+    /** Array of archive entries */
+    entries: ArchiveEntry[];
+    /** Archive format (if detected) */
+    format?: string;
+    /** Whether archive is encrypted */
+    encrypted?: boolean;
+    /** Whether archive is solid */
+    solid?: boolean;
+}
+/**
+ * Hash calculation result
+ */
+interface HashResult {
+    /** File path */
+    file: string;
+    /** Hash values keyed by filename */
+    hashes: Record<string, string>;
+    /** Total file size in bytes */
+    size: number;
+}
+/**
+ * Test result
+ */
+interface TestResult {
+    /** Archive file path */
+    archive: string;
+    /** Whether all files passed integrity check */
+    ok: boolean;
+    /** List of any errors encountered */
+    errors: string[];
+    /** Number of files tested */
+    filesTested?: number;
+}
+/**
+ * Statistics for operations
+ */
+interface OperationStats {
+    /** Number of files processed */
+    filesProcessed: number;
+    /** Total uncompressed size in bytes */
+    totalSize: number;
+    /** Total compressed size in bytes */
+    compressedSize: number;
+    /** Compression ratio (compressed/original) */
+    ratio: number;
+    /** Time elapsed in milliseconds */
+    elapsed: number;
+}
+/**
+ * Archive information
+ */
+interface ArchiveInfo {
+    /** Archive file path */
+    path: string;
+    /** Archive format */
+    format: string;
+    /** Physical size on disk */
+    physicalSize: number;
+    /** Headers size */
+    headersSize?: number;
+    /** Whether archive is solid */
+    solid?: boolean;
+    /** Number of blocks (for solid archives) */
+    blocks?: number;
+    /** Compression method */
+    method?: string;
+}
+
+/**
+ * Compression-related types
+ */
+/**
+ * Compression levels (0 = store, 9 = ultra)
+ */
+type CompressionLevel = 0 | 1 | 3 | 5 | 7 | 9;
+/**
+ * Compression methods
+ */
+type CompressionMethod = 'copy' | 'deflate' | 'deflate64' | 'bzip2' | 'lzma' | 'lzma2' | 'lz77' | 'ppmd' | 'delta';
+/**
+ * Volume size for splitting (e.g., '10m', '100k', '1g')
+ */
+type VolumeSize = string;
+/**
+ * Hash types
+ */
+type HashType = 'crc32' | 'crc64' | 'sha1' | 'sha256' | 'blake2sp';
+/**
+ * Compression options
+ */
+interface CompressionOptions {
+    /** Compression level (0-9) */
+    level?: CompressionLevel;
+    /** Compression method */
+    method?: CompressionMethod;
+    /** Dictionary size (e.g., '32m', '64m') */
+    dictionarySize?: string;
+    /** Word size */
+    wordSize?: number;
+    /** Block size for solid compression */
+    blockSize?: string;
+    /** Number of CPU threads */
+    threads?: number;
+}
+/**
+ * Compression presets for common use cases
+ */
+interface CompressionPreset {
+    name: string;
+    level: CompressionLevel;
+    method?: CompressionMethod;
+    dictionarySize?: string;
+    solid?: boolean;
+}
+/**
+ * Predefined compression presets
+ */
+declare const COMPRESSION_PRESETS: Record<string, CompressionPreset>;
+
+/**
+ * Option interfaces for 7-Zip operations
+ */
+
+/**
+ * Password protection options
+ */
+interface PasswordOptions {
+    /** Password to encrypt/decrypt archive */
+    password: string;
+    /** Encrypt filenames (7z format only) */
+    encryptFilenames?: boolean;
+}
+/**
+ * Progress callback type
+ */
+type ProgressCallback = (progress: {
+    /** Current file being processed */
+    file?: string;
+    /** Percentage complete (0-100) */
+    percent?: number;
+    /** Total bytes to process */
+    total?: number;
+    /** Bytes processed so far */
+    processed?: number;
+}) => void;
+/**
+ * Options for add operation
+ */
+interface AddOptions extends Partial<PasswordOptions> {
+    /** Archive type (default: '7z') */
+    type?: ArchiveType;
+    /** Compression level (0-9) */
+    level?: CompressionLevel;
+    /** Compression method */
+    method?: CompressionMethod;
+    /** Dictionary size (e.g., '32m', '64m') */
+    dictionarySize?: string;
+    /** Word size for compression */
+    wordSize?: number;
+    /** Number of CPU threads to use */
+    threads?: number;
+    /** Create solid archive (better compression, slower random access) */
+    solid?: boolean;
+    /** Create self-extracting archive */
+    sfx?: boolean;
+    /** Create multi-volume archive (e.g., '10m', '100k') */
+    volumes?: VolumeSize;
+    /** Wildcard patterns for files to exclude */
+    excludePatterns?: string[];
+    /** Wildcard patterns for files to include */
+    includePatterns?: string[];
+    /** Recurse into subdirectories (default: true) */
+    recursive?: boolean;
+    /** Follow symbolic links instead of storing them */
+    followSymlinks?: boolean;
+    /** Store symlinks as symlinks (Unix only) */
+    storeSymlinks?: boolean;
+    /** Progress callback */
+    onProgress?: ProgressCallback;
+    /** Store file timestamps */
+    storeTimestamps?: boolean;
+    /** Working directory */
+    cwd?: string;
+}
+/**
+ * Options for extract operation
+ */
+interface ExtractOptions extends Partial<PasswordOptions> {
+    /** Output directory */
+    outputDir?: string;
+    /** Specific files to extract (wildcards supported) */
+    files?: string[];
+    /** Wildcard patterns for files to exclude */
+    excludePatterns?: string[];
+    /** Wildcard patterns for files to include */
+    includePatterns?: string[];
+    /** Overwrite existing files */
+    overwrite?: boolean;
+    /** Preserve file permissions (Unix only) */
+    preservePermissions?: boolean;
+    /** Extract with full paths */
+    fullPaths?: boolean;
+    /** Progress callback */
+    onProgress?: ProgressCallback;
+    /** Flatten directory structure */
+    flat?: boolean;
+}
+/**
+ * Options for list operation
+ */
+interface ListOptions {
+    /** Include technical information */
+    technical?: boolean;
+    /** Enable verbose mode */
+    verbose?: boolean;
+    /** Exclude paths from output */
+    excludePaths?: boolean;
+    /** Password for encrypted archives */
+    password?: string;
+}
+/**
+ * Options for update operation
+ */
+interface UpdateOptions {
+    /** Files to add to archive */
+    add?: string[];
+    /** Files to update (freshen) in archive */
+    update?: string[];
+    /** Files/patterns to delete from archive */
+    delete?: string[];
+    /** Progress callback */
+    /** Progress callback */
+    onProgress?: ProgressCallback;
+    /** Working directory */
+    cwd?: string;
+}
+/**
+ * Options for rename operation
+ */
+interface RenameOptions {
+    /** Progress callback */
+    onProgress?: ProgressCallback;
+}
+/**
+ * Extended exec options with 7-Zip specific settings
+ */
+interface ExtendedExecOptions extends ExecOptions {
+    /** Override 7-Zip binary path */
+    binaryPath?: string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Progress callback */
+    onProgress?: ProgressCallback;
+}
+/**
+ * Generic command options
+ */
+interface CommandOptions extends Partial<PasswordOptions>, ExtendedExecOptions {
+}
+
+/**
+ * Type definitions for 7-Zip wrapper
+ *
+ * Re-exports all types from domain-specific files for convenience.
+ */
+
+/**
+ * File matching patterns (glob-style)
+ */
+type WildcardPattern = string;
+
+/**
+ * 7-Zip command implementations
+ */
+
+/**
+ * Add files to archive
+ */
+declare function add(archive: string, files: string | string[], options?: AddOptions): Promise<ArchiveResult>;
+/**
+ * Extract files from archive
+ */
+declare function extract(archive: string, options?: ExtractOptions): Promise<ArchiveResult>;
+/**
+ * List archive contents
+ */
+declare function list(archive: string, options?: ListOptions): Promise<ListResult>;
+/**
+ * Update existing archive
+ */
+declare function update(archive: string, options: UpdateOptions): Promise<ArchiveResult>;
+/**
+ * Delete files from archive
+ */
+declare function deleteFiles(archive: string, wildcards: string | string[]): Promise<ArchiveResult>;
+/**
+ * Test archive integrity
+ */
+declare function test(archive: string, password?: string): Promise<TestResult>;
+/**
+ * Calculate file hashes
+ */
+declare function hash(files: string | string[], hashType?: HashType): Promise<HashResult>;
+/**
+ * Calculate archive hashes
+ */
+declare function hashArchive(archive: string, hashType?: HashType): Promise<HashResult>;
+/**
+ * Get archive info
+ */
+declare function info(archive: string): Promise<string>;
+/**
+ * Rename files in archive
+ */
+declare function rename(archive: string, oldName: string, newName: string): Promise<ArchiveResult>;
+/**
+ * Extract and repack to different format
+ */
+declare function convert(sourceArchive: string, targetFormat: string, outputArchive?: string): Promise<ArchiveResult>;
+/**
+ * Benchmark compression
+ */
+declare function benchmark(methods?: string[], iterations?: number): Promise<ArchiveResult>;
+
+/**
+ * Custom error classes for 7-Zip wrapper
+ */
+/**
+ * Base error class for all 7-Zip related errors
+ */
+declare class ZipWrapperError extends Error {
+    readonly code?: string | undefined;
+    readonly exitCode?: number | null | undefined;
+    constructor(message: string, code?: string | undefined, exitCode?: number | null | undefined);
+}
+/**
+ * Thrown when the 7-Zip binary cannot be found
+ */
+declare class BinaryNotFoundError extends ZipWrapperError {
+    constructor(searchedPaths?: string[]);
+}
+/**
+ * Thrown when an archive file cannot be found
+ */
+declare class ArchiveNotFoundError extends ZipWrapperError {
+    readonly archivePath: string;
+    constructor(archivePath: string);
+}
+/**
+ * Thrown when a password is required but not provided
+ */
+declare class PasswordRequiredError extends ZipWrapperError {
+    readonly archivePath?: string | undefined;
+    constructor(archivePath?: string | undefined);
+}
+/**
+ * Thrown when the provided password is incorrect
+ */
+declare class WrongPasswordError extends ZipWrapperError {
+    readonly archivePath?: string | undefined;
+    constructor(archivePath?: string | undefined);
+}
+/**
+ * Thrown when an archive is corrupted or damaged
+ */
+declare class CorruptArchiveError extends ZipWrapperError {
+    readonly archivePath: string;
+    readonly details?: string | undefined;
+    constructor(archivePath: string, details?: string | undefined);
+}
+/**
+ * Thrown when compression fails
+ */
+declare class CompressionError extends ZipWrapperError {
+    constructor(message: string, exitCode?: number | null);
+}
+/**
+ * Thrown when extraction fails
+ */
+declare class ExtractionError extends ZipWrapperError {
+    constructor(message: string, exitCode?: number | null);
+}
+/**
+ * Thrown when an unsupported format is encountered
+ */
+declare class UnsupportedFormatError extends ZipWrapperError {
+    readonly format: string;
+    constructor(format: string);
+}
+/**
+ * Thrown when the operation times out
+ */
+declare class TimeoutError extends ZipWrapperError {
+    readonly timeoutMs: number;
+    readonly operation?: string | undefined;
+    constructor(timeoutMs: number, operation?: string | undefined);
+}
+/**
+ * Parse error message from 7-Zip output and return appropriate error
+ */
+declare function parseZipWrapperError(stderr: string, stdout: string, exitCode: number | null, archivePath?: string): ZipWrapperError;
+
+/**
+ * 7-Zip wrapper for Node.js
+ *
+ * A comprehensive wrapper around the 7-Zip command-line utility.
+ * Provides a clean, promise-based API for all 7-Zip operations.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Main ZipWrapper class for object-oriented usage
+ *
+ * @example
+ * ```typescript
+ * const zip = new ZipWrapper();
+ *
+ * // Create archive
+ * await zip.add('backup.7z', ['src/', 'package.json']);
+ *
+ * // Extract archive
+ * await zip.extract('backup.7z', { outputDir: 'restored/' });
+ * ```
+ */
+declare class ZipWrapper {
+    binaryPath?: string | undefined;
+    /**
+     * Create a new ZipWrapper instance
+     * @param binaryPath - Optional custom path to 7za binary
+     */
+    constructor(binaryPath?: string | undefined);
+    /**
+     * Add files to archive
+     * @param archive - Path to the archive file
+     * @param files - Files or directories to add (supports wildcards)
+     * @param options - Compression options
+     *
+     * @example
+     * ```typescript
+     * await zip.add('archive.7z', 'src/', {
+     *   level: 9,
+     *   method: 'lzma2',
+     *   password: 'secret'
+     * });
+     * ```
+     */
+    add(archive: string, files: string | string[], options?: AddOptions): Promise<ArchiveResult>;
+    /**
+     * Extract files from archive
+     * @param archive - Path to the archive file
+     * @param options - Extraction options
+     */
+    extract(archive: string, options?: ExtractOptions): Promise<ArchiveResult>;
+    /**
+     * List archive contents
+     * @param archive - Path to the archive file
+     * @param options - List options
+     */
+    list(archive: string, options?: ListOptions): Promise<ListResult>;
+    /**
+     * Update existing archive
+     * @param archive - Path to the archive file
+     * @param options - Update options
+     */
+    update(archive: string, options: UpdateOptions): Promise<ArchiveResult>;
+    /**
+     * Delete files from archive
+     * @param archive - Path to the archive file
+     * @param wildcards - Patterns to match files to delete
+     */
+    delete(archive: string, wildcards: string | string[]): Promise<ArchiveResult>;
+    /**
+     * Test archive integrity
+     * @param archive - Path to the archive file
+     * @param password - Optional password for encrypted archives
+     */
+    test(archive: string, password?: string): Promise<TestResult>;
+    /**
+     * Add file to archive from stream
+     * @param archive Path to archive
+     * @param filename Filename inside archive
+     * @param stream Input stream
+     * @param options Compression options
+     */
+    addFromStream(archive: string, filename: string, stream: Readable, options?: AddOptions): Promise<void>;
+    /**
+     * Extract file from archive to stream
+     * @param archive Path to archive
+     * @param filename Filename to extract
+     * @returns Readable stream of file content
+     */
+    extractToStream(archive: string, filename: string, options?: CommandOptions): Readable;
+    /**
+     * Extract file from archive to buffer
+     * @param archive Path to archive
+     * @param filename Filename to extract
+     * @returns Promise resolving to Buffer of file content
+     */
+    extractToBuffer(archive: string, filename: string, options?: CommandOptions): Promise<Buffer>;
+    /**
+     * Calculate file hashes
+     * @param files - Files to hash (e.g. `['file.txt']` or `'*.txt'`)
+     * @param hashType - Hash algorithm (default: 'crc32')
+     * @returns Map of file paths to hashes
+     *
+     * @example
+     * ```typescript
+     * const hashes = await zip.hash(['file.txt'], 'sha256');
+     * console.log(hashes.get('file.txt'));
+     * ```
+     */
+    hash(files: string | string[], hashType?: HashType): Promise<HashResult>;
+    /**
+     * Get archive info
+     * @param archive - Path to the archive file
+     */
+    info(archive: string): Promise<string>;
+    /**
+     * Run benchmark
+     * @param methods - Optional compression methods to benchmark
+     * @param iterations - Optional number of iterations
+     */
+    benchmark(methods?: string[], iterations?: number): Promise<ArchiveResult>;
+    /**
+     * Convert archive to different format
+     * @param sourceArchive - Source archive path
+     * @param targetFormat - Target format (7z, zip, etc.)
+     * @param outputArchive - Optional output path
+     */
+    convert(sourceArchive: string, targetFormat: string, outputArchive?: string): Promise<ArchiveResult>;
+}
+/**
+ * Default ZipWrapper instance
+ */
+declare const zipWrapper: ZipWrapper;
+/**
+ * Quick helper functions for common operations
+ */
+declare const quick: {
+    /**
+     * Quick ZIP creation with max compression
+     * @param files - Files to archive
+     * @param output - Output archive path
+     */
+    zip(files: string | string[], output: string): Promise<ArchiveResult>;
+    /**
+     * Quick 7z creation with max compression
+     * @param files - Files to archive
+     * @param output - Output archive path
+     */
+    sevenz(files: string | string[], output: string): Promise<ArchiveResult>;
+    /**
+     * Quick extraction to directory
+     * @param archive - Archive to extract
+     * @param outputDir - Optional output directory
+     */
+    extract(archive: string, outputDir?: string): Promise<ArchiveResult>;
+    /**
+     * Quick listing
+     * @param archive - Archive to list
+     */
+    list(archive: string): Promise<ListResult>;
+    /**
+     * Quick integrity test
+     * @param archive - Archive to test
+     */
+    test(archive: string): Promise<TestResult>;
+};
+
+export { type AddOptions, type ArchiveEntry, type ArchiveFormat, type ArchiveInfo, ArchiveNotFoundError, type ArchiveResult, type ArchiveType, BinaryNotFoundError, COMPRESSION_PRESETS, CompressionError, type CompressionLevel, type CompressionMethod, type CompressionOptions, type CompressionPreset, CorruptArchiveError, type ExtendedExecOptions, type ExtractOptions, ExtractionError, type HashResult, type HashType, type ListOptions, type ListResult, type OperationStats, type PasswordOptions, PasswordRequiredError, type ProgressCallback, type RenameOptions, type TestResult, TimeoutError, UnsupportedFormatError, type UpdateOptions, type VolumeSize, type WildcardPattern, WrongPasswordError, ZipWrapper, ZipWrapperError, add, benchmark, convert, deleteFiles, extract, hash, hashArchive, info, list, parseZipWrapperError, quick, rename, test, update, zipWrapper };

package/dist/index.js

@@ -0,0 +1,5 @@
+'use strict';var O=require('fs'),child_process=require('child_process'),N=require('path'),lt=require('os');function _interopDefault(e){return e&&e.__esModule?e:{default:e}}var O__default=/*#__PURE__*/_interopDefault(O);var N__default=/*#__PURE__*/_interopDefault(N);var lt__default=/*#__PURE__*/_interopDefault(lt);var J={fastest:{name:"Fastest",level:1},fast:{name:"Fast",level:3},normal:{name:"Normal",level:5},maximum:{name:"Maximum",level:7},ultra:{name:"Ultra",level:9,method:"lzma2",dictionarySize:"64m",solid:true}};var A={SUCCESS:0,WARNING:1};var Q={win32:"7za.exe",linux:"7za",darwin:"7za"},i={TYPE:"-t",LEVEL:"-mx",METHOD:"-m0",DICT_SIZE:"-md",WORD_SIZE:"-mfbc",THREADS:"-mmt",SOLID:"-ms",ENCRYPT_HEADERS:"-mhe",PASSWORD:"-p",OUTPUT:"-o",OVERWRITE_ALL:"-aoa",SKIP_EXISTING:"-aos",TECH_INFO:"-slt",VERBOSE:"-bb1",RECURSE:"-r",NO_RECURSE:"-r-",INCLUDE:"-i!",EXCLUDE:"-x!",STORE_SYMLINKS:"-snl",STORE_HARDLINKS:"-snh",TIMESTAMPS:"-bt",YES:"-y",SFX:"-sfx",VOLUME:"-v",PRESERVE_PERMISSIONS:"-spf"},d={ADD:"a",EXTRACT:"x",EXTRACT_FLAT:"e",LIST:"l",TEST:"t",UPDATE:"u",DELETE:"d",RENAME:"rn",HASH:"h",INFO:"i",BENCHMARK:"b"};var tt=3e4;var p=class extends Error{constructor(t,s,n){super(t);this.code=s;this.exitCode=n;this.name="ZipWrapperError",Error.captureStackTrace?.(this,this.constructor);}},y=class extends p{constructor(r=[]){let t=r.length>0?` Searched: ${r.join(", ")}`:"";super(`7-Zip binary not found.${t}`,"BINARY_NOT_FOUND"),this.name="BinaryNotFoundError";}},S=class extends p{constructor(t){super(`Archive not found: ${t}`,"ARCHIVE_NOT_FOUND");this.archivePath=t;this.name="ArchiveNotFoundError";}},T=class extends p{constructor(t){super(t?`Password required for archive: ${t}`:"Password required for encrypted archive","PASSWORD_REQUIRED");this.archivePath=t;this.name="PasswordRequiredError";}},C=class extends p{constructor(t){super(t?`Wrong password for archive: ${t}`:"Wrong password for encrypted archive","WRONG_PASSWORD");this.archivePath=t;this.name="WrongPasswordError";}},w=class extends p{constructor(t,s){super(s?`Corrupt archive: ${t} - ${s}`:`Corrupt archive: ${t}`,"CORRUPT_ARCHIVE");this.archivePath=t;this.details=s;this.name="CorruptArchiveError";}},b=class extends p{constructor(r,t){super(r,"COMPRESSION_ERROR",t),this.name="CompressionError";}},_=class extends p{constructor(r,t){super(r,"EXTRACTION_ERROR",t),this.name="ExtractionError";}},D=class extends p{constructor(t){super(`Unsupported archive format: ${t}`,"UNSUPPORTED_FORMAT");this.format=t;this.name="UnsupportedFormatError";}},x=class extends p{constructor(t,s){super(s?`Operation '${s}' timed out after ${t}ms`:`Operation timed out after ${t}ms`,"TIMEOUT");this.timeoutMs=t;this.operation=s;this.name="TimeoutError";}};function L(e,r,t,s){let n=`${e}
+${r}`.toLowerCase();return n.includes("wrong password")||n.includes("incorrect password")?new C(s):n.includes("enter password")||n.includes("password is required")||n.includes("encrypted")?new T(s):n.includes("data error")||n.includes("crc failed")||n.includes("headers error")||n.includes("unexpected end")?new w(s||"unknown",e.trim()):(n.includes("cannot find archive")||n.includes("cannot open"))&&s?new S(s):new b(e.trim()||"Unknown 7-Zip error",t)}function ct(e){let r=e;for(;;){if(O__default.default.existsSync(N__default.default.join(r,"package.json")))return r;let t=N__default.default.dirname(r);if(t===r)return e;r=t;}}var ut=ct(__dirname),rt=N__default.default.join(ut,"bin");var I=null;function M(){return I||(I=N__default.default.join(rt,Q[lt__default.default.platform()]),I)}M();function ft(e){return e||M()}function ht(e){let r=e||M();if(!O__default.default.existsSync(r))return  false;try{return child_process.execSync(`"${r}"`,{timeout:5e3,windowsHide:!0,stdio:"ignore"}),!0}catch{return  true}}function et(e){let r=ft(e);if(!ht(r)){let t=[r];throw new y(t)}return r}function z(e,r){let t=et(r?.binaryPath);try{return child_process.spawn(t,e,{...r,windowsHide:!0,stdio:["pipe","pipe","pipe"]})}catch(s){throw new p(`Failed to spawn 7-Zip process: ${s.message}`)}}async function h(e,r){let s=r?.timeout??tt;return new Promise((n,o)=>{let l=[],a=[],u,c,Z=false;try{u=z(e,r);}catch(m){o(m);return}s>0&&(c=setTimeout(()=>{Z=true,u.kill("SIGTERM"),o(new x(s,`7za ${e[0]}`));},s)),u.stdout?.on("data",m=>{l.push(m),r?.onProgress&&gt(m.toString("utf-8"),r.onProgress);}),u.stderr?.on("data",m=>{a.push(m);}),u.on("close",m=>{if(c&&clearTimeout(c),Z)return;let K=Buffer.concat(l).toString("utf-8"),j=Buffer.concat(a).toString("utf-8"),G={success:m===A.SUCCESS,command:`7za ${e.join(" ")}`,stdout:K,stderr:j,exitCode:m};if(m===A.SUCCESS||m===A.WARNING)n(G);else {let q=L(j,K,m,r?.archivePath);Object.assign(q,{result:G}),o(q);}}),u.on("error",m=>{c&&clearTimeout(c),o(new p(`Failed to execute 7-Zip: ${m.message}`));});})}function gt(e,r){let t=e.match(/(\d+)%/);t&&r({percent:parseInt(t[1],10)});let s=e.match(/- (.+)$/m);s&&r({file:s[1].trim()});}function st(e){let r=e.split(`
+`),t=[],s=0,n=0,o=0,l=0,a=null;for(let u of r){let c=u.trim();c.startsWith("Path = ")?(a?.path&&t.push(a),a={path:c.substring(7),size:0,packedSize:0,modified:new Date,attributes:"",crc:"",method:"",isDirectory:false}):a&&(c.startsWith("Size = ")?a.size=parseInt(c.substring(7),10)||0:c.startsWith("Packed Size = ")?a.packedSize=parseInt(c.substring(14),10)||0:c.startsWith("Modified = ")?a.modified=new Date(c.substring(11)):c.startsWith("Attributes = ")?(a.attributes=c.substring(13),a.isDirectory=a.attributes.includes("D")):c.startsWith("CRC = ")?a.crc=c.substring(6):c.startsWith("Method = ")?a.method=c.substring(9):c.startsWith("Encrypted = ")&&(a.encrypted=c.substring(12)==="+"));}a?.path&&t.push(a);for(let u of t)u.isDirectory?l++:(o++,s+=u.size,n+=u.packedSize);return {entries:t,stats:{totalSize:s,totalPackedSize:n,fileCount:o,dirCount:l,ratio:s>0?n/s:0}}}function U(e){let r=e.split(`
+`),t={};for(let s of r){let n=s.match(/(\w+)\s+for data:\s+([0-9A-Fa-f]+)/);if(n){t[n[1].toLowerCase()]=n[2];continue}let o=s.match(/^([0-9A-Fa-f]+)\s+(.+)$/);if(o){let l=o[1],a=o[2].trim();t[a]=l;}}return t}function nt(e){let r=e.split(`
+`),t=[],s=true;for(let n of r){let o=n.toLowerCase();(o.includes("error")||o.includes("failed")||o.includes("cannot")||o.includes("crc failed"))&&(t.push(n.trim()),s=false);}return e.includes("Everything is Ok")&&(s=true,t.length=0),{ok:s,errors:t}}function f(e,r,t,s){let n=[e];return n.push(...r),t&&n.push(t),s&&s.length>0&&n.push(...s),n}function E(e){if(!O__default.default.existsSync(e))throw new S(e)}async function it(e,r,t,s={}){let n=[`-si${r}`];s.password&&n.push(`-p${s.password}`),s.level&&n.push(`-mx=${s.level}`),s.method&&n.push(`-m0=${s.method}`),n.push(i.YES);let o=f(d.ADD,n,e);return new Promise((l,a)=>{try{let u=z(o,{...s,archivePath:e});t.pipe(u.stdin),u.on("close",c=>{c===0?l():a(new Error(`7-Zip exited with code ${c}`));}),u.on("error",c=>a(c)),t.on("error",c=>a(c));}catch(u){a(u);}})}function H(e,r,t={}){E(e);let s=["-so"];t.password&&s.push(`-p${t.password}`),s.push(i.YES);let n=f(d.EXTRACT,s,e,[r]),o=z(n,{...t,archivePath:e});if(!o.stdout)throw new p("Failed to get stdout from 7-Zip process");return o.stdout}async function ot(e,r,t={}){let s=H(e,r,t);return new Promise((n,o)=>{let l=[];s.on("data",a=>l.push(Buffer.from(a))),s.on("error",a=>o(a)),s.on("end",()=>n(Buffer.concat(l)));})}async function R(e,r,t){let s=[];if(t?.type&&s.push(`${i.TYPE}${t.type}`),t?.level!==void 0&&s.push(`${i.LEVEL}=${t.level}`),t?.method&&s.push(`${i.METHOD}=${t.method}`),t?.dictionarySize&&s.push(`${i.DICT_SIZE}=${t.dictionarySize}`),t?.wordSize!==void 0&&s.push(`${i.WORD_SIZE}=${t.wordSize}`),t?.threads!==void 0&&s.push(`${i.THREADS}${t.threads}`),t?.solid&&s.push(`${i.SOLID}=on`),t?.sfx&&s.push(i.SFX),t?.volumes&&s.push(`${i.VOLUME}${t.volumes}`),t?.password&&(s.push(`${i.PASSWORD}${t.password}`),t.encryptFilenames&&s.push(`${i.ENCRYPT_HEADERS}=on`)),t?.includePatterns)for(let o of t.includePatterns)s.push(`${i.INCLUDE}${o}`);if(t?.excludePatterns)for(let o of t.excludePatterns)s.push(`${i.EXCLUDE}${o}`);t?.recursive===false?s.push(i.NO_RECURSE):s.push(i.RECURSE),t?.followSymlinks&&(s.push(`${i.STORE_HARDLINKS}-`),s.push(`${i.STORE_SYMLINKS}-`)),t?.storeSymlinks&&(s.push(i.STORE_HARDLINKS),s.push(i.STORE_SYMLINKS)),s.push(i.YES);let n=Array.isArray(r)?r:[r];return h(f(d.ADD,s,e,n),{onProgress:t?.onProgress,cwd:t?.cwd})}async function P(e,r){E(e);let t=[i.YES];if(r?.outputDir&&t.push(`${i.OUTPUT}${r.outputDir}`),r?.password&&t.push(`${i.PASSWORD}${r.password}`),r?.includePatterns)for(let o of r.includePatterns)t.push(`${i.INCLUDE}${o}`);if(r?.excludePatterns)for(let o of r.excludePatterns)t.push(`${i.EXCLUDE}${o}`);r?.overwrite===false?t.push(i.SKIP_EXISTING):r?.overwrite===true&&t.push(i.OVERWRITE_ALL),r?.preservePermissions&&t.push(i.PRESERVE_PERMISSIONS);let s=r?.files||[],n=r?.flat?d.EXTRACT_FLAT:d.EXTRACT;return h(f(n,t,e,s),{archivePath:e,onProgress:r?.onProgress})}async function v(e,r){E(e);let t=[i.TECH_INFO];r?.verbose&&t.push(i.VERBOSE),r?.password&&t.push(`${i.PASSWORD}${r.password}`);let s=await h(f(d.LIST,t,e),{archivePath:e}),n=st(s.stdout);return {archive:e,size:n.stats.totalSize,packedSize:n.stats.totalPackedSize,fileCount:n.stats.fileCount,dirCount:n.stats.dirCount,entries:n.entries}}async function B(e,r){E(e);let t=[i.YES],s=[];if(r.add&&s.push(...r.add),r.update)for(let n of r.update)s.push(`!${n}`);return h(f(d.UPDATE,t,e,s),{archivePath:e,onProgress:r.onProgress,cwd:r.cwd})}async function F(e,r){E(e);let t=[i.YES],s=Array.isArray(r)?r:[r];return h(f(d.DELETE,t,e,s),{archivePath:e})}async function $(e,r){E(e);let t=[i.TIMESTAMPS];r&&t.push(`${i.PASSWORD}${r}`);let s=await h(f(d.TEST,t,e),{archivePath:e}),n=nt(s.stdout+s.stderr);return {archive:e,ok:s.success&&n.ok,errors:n.errors}}async function k(e,r="crc32"){let t=[`-scrc${r}`],s=Array.isArray(e)?e:[e],n=0;for(let a of s)try{let u=O__default.default.statSync(a);n+=u.size;}catch{}let o=await h(f(d.HASH,t,void 0,s)),l=U(o.stdout);return {file:Array.isArray(e)?e[0]:e,hashes:l,size:n}}async function St(e,r="crc32"){E(e);let t=[`-scrc${r}`],s=await h(f(d.HASH,t,e),{archivePath:e}),n=U(s.stdout),o=O__default.default.statSync(e);return {file:e,hashes:n,size:o.size}}async function W(e){return E(e),(await h(f(d.INFO,[],e),{archivePath:e})).stdout}async function Rt(e,r,t){E(e);let s=[i.YES];return h(f(d.RENAME,s,e,[r,t]),{archivePath:e})}async function Y(e,r,t){E(e);let s=`${e}_temp_${Date.now()}`;O__default.default.mkdirSync(s,{recursive:true});try{await P(e,{outputDir:s});let n=t||e.replace(/\.[^.]+$/,`.${r}`);return await R(n,s,{type:r})}finally{O__default.default.rmSync(s,{recursive:true,force:true});}}async function X(e,r){let t=[i.VERBOSE];if(e)for(let s of e)t.push(`-mm=${s}`);return r&&t.push(`-mmt=${r}`),h(f(d.BENCHMARK,t))}var V=class{constructor(r){this.binaryPath=r;}async add(r,t,s){return R(r,t,s)}async extract(r,t){return P(r,t)}async list(r,t){return v(r,t)}async update(r,t){return B(r,t)}async delete(r,t){return F(r,t)}async test(r,t){return $(r,t)}async addFromStream(r,t,s,n){return it(r,t,s,n)}extractToStream(r,t,s){return H(r,t,s)}async extractToBuffer(r,t,s){return ot(r,t,s)}async hash(r,t){return k(r,t)}async info(r){return W(r)}async benchmark(r,t){return X(r,t)}async convert(r,t,s){return Y(r,t,s)}},rr=new V,er={async zip(e,r){return R(r,e,{type:"zip",level:9})},async sevenz(e,r){return R(r,e,{type:"7z",level:9})},async extract(e,r){return P(e,{outputDir:r})},async list(e){return v(e)},async test(e){return $(e)}};exports.ArchiveNotFoundError=S;exports.BinaryNotFoundError=y;exports.COMPRESSION_PRESETS=J;exports.CompressionError=b;exports.CorruptArchiveError=w;exports.ExtractionError=_;exports.PasswordRequiredError=T;exports.TimeoutError=x;exports.UnsupportedFormatError=D;exports.WrongPasswordError=C;exports.ZipWrapper=V;exports.ZipWrapperError=p;exports.add=R;exports.benchmark=X;exports.convert=Y;exports.deleteFiles=F;exports.extract=P;exports.hash=k;exports.hashArchive=St;exports.info=W;exports.list=v;exports.parseZipWrapperError=L;exports.quick=er;exports.rename=Rt;exports.test=$;exports.update=B;exports.zipWrapper=rr;