7zip-native 0.0.6 → 0.0.8

package/dist/index.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var node_fs = require('node:fs');
-var promises$1 = require('node:fs/promises');
+var promises = require('node:fs/promises');
 var node_crypto = require('node:crypto');
 var node_module = require('node:module');
 var node_os = require('node:os');
 var node_path = require('node:path');
 var node_stream = require('node:stream');
-var promises = require('node:stream/promises');
-var node_url = require('node:url');
+var promises$1 = require('node:stream/promises');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 class ArchiveError extends Error {
@@ -47,7 +46,7 @@ if (process.platform === 'win32') {
 else if (process.platform === 'darwin') {
     engineName = 'lib7z.dylib';
 }
-const packageDirectory = node_path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+const packageDirectory = node_path.dirname(require$1.resolve('7zip-native'));
 const runtimeDirectory = [
     node_path.resolve(packageDirectory, `../prebuilds/${process.platform}-${process.arch}`),
     node_path.resolve(packageDirectory, '../build/Release'),
@@ -76,10 +75,32 @@ function safeEntrySegments(entryPath) {
     }
     return segments;
 }
+function sanitizeOutputPath(entryPath) {
+    if (process.platform !== 'win32') {
+        return entryPath;
+    }
+    return entryPath
+        .replace(/([. ]+)([\\/]|$)/g, (_match, unsupported, separator) => '_'.repeat(unsupported.length) + separator)
+        .replace(/[<>:|?*"]/g, '_');
+}
+function assertSafeRelativeArchivePath(entryPath) {
+    const normalized = entryPath.replace(/\\/g, '/');
+    const segments = normalized.split('/').filter(segment => segment !== '' && segment !== '.');
+    if (entryPath.includes('\0')
+        || normalized.startsWith('/')
+        || /^[a-zA-Z]:/.test(normalized)
+        || segments.length === 0
+        || segments.some(segment => segment === '..')) {
+        throw new ArchiveError('ERR_ARCHIVE_PATH', `Unsafe archive entry path: ${entryPath}`);
+    }
+}
 function makeOutputPlans(root, entries) {
     const caseInsensitivePaths = process.platform === 'win32' || process.platform === 'darwin';
     const plans = entries.map((entry) => {
-        const segments = safeEntrySegments(entry.path);
+        if (process.platform === 'win32') {
+            assertSafeRelativeArchivePath(entry.path);
+        }
+        const segments = safeEntrySegments(sanitizeOutputPath(entry.path));
         const targetPath = node_path.resolve(root, ...segments);
         const relative = node_path.relative(root, targetPath);
         if (relative === ''
@@ -113,21 +134,21 @@ function makeOutputPlans(root, entries) {
 }
 async function ensureDirectory(directoryPath) {
     try {
-        await promises$1.mkdir(directoryPath, { mode: 0o700 });
+        await promises.mkdir(directoryPath, { mode: 0o700 });
     }
     catch (error) {
         if (error.code !== 'EEXIST') {
             throw error;
         }
     }
-    const details = await promises$1.lstat(directoryPath);
+    const details = await promises.lstat(directoryPath);
     if (details.isSymbolicLink() || !details.isDirectory()) {
         throw new ArchiveError('ERR_ARCHIVE_PATH', `Destination path is not a real directory: ${directoryPath}`);
     }
 }
 async function assertReplaceableOutput(filePath) {
     try {
-        const details = await promises$1.lstat(filePath);
+        const details = await promises.lstat(filePath);
         if (!details.isFile()) {
             throw new ArchiveError('ERR_ARCHIVE_PATH', `Cannot replace a non-file extraction target: ${filePath}`);
         }
@@ -138,9 +159,40 @@ async function assertReplaceableOutput(filePath) {
         }
     }
 }
+async function assertOutputDoesNotExist(filePath) {
+    try {
+        await promises.lstat(filePath);
+        throw new ArchiveError('ERR_ARCHIVE_CREATE', `Output archive already exists: ${filePath}`);
+    }
+    catch (error) {
+        if (error instanceof ArchiveError || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+async function normalizeCreateEntry(entry) {
+    if (entry === null || typeof entry !== 'object'
+        || typeof entry.sourcePath !== 'string' || entry.sourcePath.length === 0
+        || typeof entry.path !== 'string' || entry.path.length === 0) {
+        throw new TypeError('Each archive creation entry must have non-empty sourcePath and path strings');
+    }
+    const internalPath = safeEntrySegments(entry.path).join('/');
+    const sourcePath = node_path.resolve(entry.sourcePath);
+    let details;
+    try {
+        details = await promises.lstat(sourcePath);
+    }
+    catch (cause) {
+        throw new ArchiveError('ERR_ARCHIVE_CREATE', `Unable to access archive creation source: ${sourcePath}`, { cause });
+    }
+    if (details.isSymbolicLink() || !details.isFile()) {
+        throw new ArchiveError('ERR_ARCHIVE_CREATE', `Archive creation source is not a regular file: ${sourcePath}`);
+    }
+    return { sourcePath, path: internalPath };
+}
 async function ensureExtractionRoot(root) {
     try {
-        const details = await promises$1.lstat(root);
+        const details = await promises.lstat(root);
         if (details.isSymbolicLink() || !details.isDirectory()) {
             throw new ArchiveError('ERR_ARCHIVE_PATH', `Destination is not a real directory: ${root}`);
         }
@@ -151,8 +203,8 @@ async function ensureExtractionRoot(root) {
             throw error;
         }
     }
-    await promises$1.mkdir(root, { recursive: true, mode: 0o700 });
-    const details = await promises$1.lstat(root);
+    await promises.mkdir(root, { recursive: true, mode: 0o700 });
+    const details = await promises.lstat(root);
     if (details.isSymbolicLink() || !details.isDirectory()) {
         throw new ArchiveError('ERR_ARCHIVE_PATH', `Destination is not a real directory: ${root}`);
     }
@@ -299,6 +351,99 @@ class Archive {
             throw new ArchiveError(/password/i.test(message) ? 'ERR_ARCHIVE_PASSWORD' : 'ERR_ARCHIVE_OPEN', message, { cause });
         }
     }
+    static async create(outputPath, entries, options = {}) {
+        if (typeof outputPath !== 'string' || outputPath.length === 0) {
+            throw new TypeError('Output archive path must be a non-empty string');
+        }
+        if (!Array.isArray(entries)) {
+            throw new TypeError('Archive creation entries must be an array');
+        }
+        if (entries.length > 1_000_000) {
+            throw new RangeError('Archive creation exceeds the 1,000,000-entry limit');
+        }
+        if (options === null || typeof options !== 'object') {
+            throw new TypeError('Archive creation options must be an object');
+        }
+        if (options.overwrite !== undefined && typeof options.overwrite !== 'boolean') {
+            throw new TypeError('Archive creation overwrite option must be a boolean');
+        }
+        const compressionLevel = options.compressionLevel ?? 5;
+        if (!Number.isSafeInteger(compressionLevel) || compressionLevel < 0 || compressionLevel > 9) {
+            throw new RangeError('Compression level must be an integer between 0 and 9');
+        }
+        const targetPath = node_path.resolve(outputPath);
+        let format;
+        if (options.format !== undefined) {
+            if (options.format !== '7z' && options.format !== 'zip'
+                && options.format !== 'tar' && options.format !== 'wim') {
+                throw new TypeError('Archive format must be "7z", "zip", "tar", or "wim"');
+            }
+            format = options.format;
+        }
+        else {
+            const extension = node_path.extname(targetPath).toLowerCase();
+            if (extension === '.7z') {
+                format = '7z';
+            }
+            else if (extension === '.zip') {
+                format = 'zip';
+            }
+            else if (extension === '.tar') {
+                format = 'tar';
+            }
+            else if (extension === '.wim') {
+                format = 'wim';
+            }
+            else {
+                throw new TypeError('Specify format as "7z", "zip", "tar", or "wim" for an unrecognized output extension');
+            }
+        }
+        if (options.compressionLevel !== undefined && format !== '7z' && format !== 'zip') {
+            throw new TypeError('compressionLevel is only supported for ZIP and 7z archives');
+        }
+        const normalizedEntries = await Promise.all(entries.map(normalizeCreateEntry));
+        const caseInsensitivePaths = process.platform === 'win32' || process.platform === 'darwin';
+        const pathKeys = normalizedEntries.map(entry => caseInsensitivePaths ? entry.path.toLowerCase() : entry.path);
+        const archivePaths = new Set(pathKeys);
+        if (archivePaths.size !== normalizedEntries.length) {
+            throw new ArchiveError('ERR_ARCHIVE_PATH', 'Archive creation paths must be unique');
+        }
+        for (const entry of normalizedEntries) {
+            const segments = entry.path.split('/');
+            for (let index = 1; index < segments.length; index++) {
+                const parent = segments.slice(0, index).join('/');
+                const parentKey = caseInsensitivePaths ? parent.toLowerCase() : parent;
+                if (archivePaths.has(parentKey)) {
+                    throw new ArchiveError('ERR_ARCHIVE_PATH', `Archive creation file path is a parent of another entry: ${parent}`);
+                }
+            }
+        }
+        if (options.overwrite) {
+            await assertReplaceableOutput(targetPath);
+        }
+        else {
+            await assertOutputDoesNotExist(targetPath);
+        }
+        const temporaryPath = node_path.join(node_path.dirname(targetPath), `.7zip-native-${node_crypto.randomUUID()}.tmp`);
+        try {
+            await native.create(temporaryPath, format, normalizedEntries, compressionLevel, enginePath);
+            if (options.overwrite) {
+                await assertReplaceableOutput(targetPath);
+                await promises.rename(temporaryPath, targetPath);
+            }
+            else {
+                await promises.link(temporaryPath, targetPath);
+                await promises.rm(temporaryPath);
+            }
+        }
+        catch (cause) {
+            await promises.rm(temporaryPath, { force: true });
+            if (cause instanceof ArchiveError) {
+                throw cause;
+            }
+            throw new ArchiveError('ERR_ARCHIVE_CREATE', errorMessage(cause), { cause });
+        }
+    }
     async entries() {
         this.assertOpen();
         this.entriesPromise ??= native.entries(this.handle).catch((cause) => {
@@ -369,7 +514,7 @@ class Archive {
         if (!destination || typeof destination.write !== 'function') {
             throw new TypeError('Destination must be a writable stream');
         }
-        await promises.pipeline(this.createReadStream(idOrPath, options), destination, { signal: options.signal });
+        await promises$1.pipeline(this.createReadStream(idOrPath, options), destination, { signal: options.signal });
     }
     async extractToFolder(destination, options = {}) {
         this.assertOpen();
@@ -382,9 +527,19 @@ class Archive {
         if (options.overwrite !== undefined && typeof options.overwrite !== 'boolean') {
             throw new TypeError('Folder extraction overwrite option must be a boolean');
         }
+        if (options.concurrency !== undefined
+            && (!Number.isSafeInteger(options.concurrency)
+                || options.concurrency < 1
+                || options.concurrency > 128)) {
+            throw new RangeError('Folder extraction concurrency must be an integer between 1 and 128');
+        }
         if (options.onProgress !== undefined && typeof options.onProgress !== 'function') {
             throw new TypeError('Folder extraction onProgress option must be a function');
         }
+        if (options.onExtract !== undefined && typeof options.onExtract !== 'function') {
+            throw new TypeError('Folder extraction onExtract option must be a function');
+        }
+        const concurrency = Math.min(options.concurrency ?? 1, Archive.concurrency());
         options.signal?.throwIfAborted();
         const maxBytes = normalizeMaxBytes(options.maxBytes, 'maxBytes');
         const entries = await this.entries();
@@ -454,8 +609,28 @@ class Archive {
             options.signal?.throwIfAborted();
             if (plan.isDirectory) {
                 await ensureOutputDirectoryTree(root, plan.targetPath);
-                continue;
             }
+        }
+        const filePlans = plans.filter(plan => !plan.isDirectory);
+        const controller = new AbortController();
+        const extractionSignal = controller.signal;
+        let hasFailure = false;
+        let failure;
+        let nextFileIndex = 0;
+        const stop = (error) => {
+            if (!hasFailure) {
+                hasFailure = true;
+                failure = error;
+            }
+            if (!extractionSignal.aborted) {
+                controller.abort(error);
+            }
+        };
+        const abortFromCaller = () => {
+            stop(options.signal?.reason);
+        };
+        options.signal?.addEventListener('abort', abortFromCaller, { once: true });
+        const extractFile = async (plan) => {
             await ensureOutputParents(root, plan.targetPath);
             const limit = new node_stream.Transform({
                 transform(chunk, _encoding, callback) {
@@ -479,26 +654,59 @@ class Archive {
                 await assertReplaceableOutput(plan.targetPath);
                 const temporaryPath = node_path.join(node_path.dirname(plan.targetPath), `.7zip-native-${node_crypto.randomUUID()}.tmp`);
                 try {
-                    await promises.pipeline(this.createReadStream(plan.entry.id, {
-                        signal: options.signal,
+                    await promises$1.pipeline(this.createReadStream(plan.entry.id, {
+                        signal: extractionSignal,
                         maxBytes: null,
-                    }), limit, node_fs.createWriteStream(temporaryPath, { flags: 'wx', mode: 0o600 }), { signal: options.signal });
+                    }), limit, node_fs.createWriteStream(temporaryPath, { flags: 'wx', mode: 0o600 }), { signal: extractionSignal });
+                    extractionSignal.throwIfAborted();
                     await assertReplaceableOutput(plan.targetPath);
-                    await promises$1.rename(temporaryPath, plan.targetPath);
+                    extractionSignal.throwIfAborted();
+                    await promises.rename(temporaryPath, plan.targetPath);
                 }
                 catch (error) {
-                    await promises$1.rm(temporaryPath, { force: true });
+                    await promises.rm(temporaryPath, { force: true });
                     throw error;
                 }
             }
             else {
-                await promises.pipeline(this.createReadStream(plan.entry.id, {
-                    signal: options.signal,
+                await promises$1.pipeline(this.createReadStream(plan.entry.id, {
+                    signal: extractionSignal,
                     maxBytes: null,
-                }), limit, node_fs.createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 }), { signal: options.signal });
+                }), limit, node_fs.createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 }), { signal: extractionSignal });
             }
             filesExtracted++;
             reportProgress();
+            options.onExtract?.({ entry: plan.entry, outputPath: plan.targetPath });
+        };
+        const runWorker = async () => {
+            while (!hasFailure) {
+                if (options.signal?.aborted) {
+                    stop(options.signal.reason);
+                    return;
+                }
+                const plan = filePlans[nextFileIndex++];
+                if (!plan) {
+                    return;
+                }
+                try {
+                    await extractFile(plan);
+                }
+                catch (error) {
+                    stop(error);
+                    return;
+                }
+            }
+        };
+        try {
+            options.signal?.throwIfAborted();
+            const workers = Array.from({ length: Math.min(concurrency, filePlans.length) }, () => runWorker());
+            await Promise.all(workers);
+            if (hasFailure) {
+                throw failure;
+            }
+        }
+        finally {
+            options.signal?.removeEventListener('abort', abortFromCaller);
         }
     }
     async read(idOrPath, options) {

package/dist/index.d.cts

@@ -19,6 +19,16 @@ interface ReadOptions {
 interface OpenOptions {
     readonly password?: string;
 }
+type ArchiveFormat = '7z' | 'zip' | 'tar' | 'wim';
+interface ArchiveCreateEntry {
+    readonly sourcePath: string;
+    readonly path: string;
+}
+interface CreateArchiveOptions {
+    readonly format?: ArchiveFormat;
+    readonly compressionLevel?: number;
+    readonly overwrite?: boolean;
+}
 interface ExtractToFolderProgress {
     readonly filesExtracted: number;
     readonly totalFiles: number;
@@ -26,6 +36,10 @@ interface ExtractToFolderProgress {
     readonly totalBytes: bigint;
     readonly percent: number;
 }
+interface ExtractedArchiveFile {
+    readonly entry: ArchiveEntry;
+    readonly outputPath: string;
+}
 interface ReadStreamOptions {
     readonly highWaterMark?: number;
     readonly maxBytes?: number | bigint | null;
@@ -34,12 +48,14 @@ interface ReadStreamOptions {
 interface ExtractToFolderOptions {
     readonly ids?: readonly EntryId[];
     readonly paths?: readonly string[];
+    readonly concurrency?: number;
     readonly overwrite?: boolean;
     readonly onProgress?: (progress: ExtractToFolderProgress) => void;
+    readonly onExtract?: (result: ExtractedArchiveFile) => void;
     readonly maxBytes?: number | bigint | null;
     readonly signal?: AbortSignal;
 }
-type ArchiveErrorCode = 'ERR_ARCHIVE_CLOSED' | 'ERR_INVALID_ENTRY' | 'ERR_INVALID_RANGE' | 'ERR_RESOURCE_LIMIT' | 'ERR_ARCHIVE_OPEN' | 'ERR_ARCHIVE_PASSWORD' | 'ERR_ARCHIVE_PATH' | 'ERR_ARCHIVE_EXTRACT';
+type ArchiveErrorCode = 'ERR_ARCHIVE_CLOSED' | 'ERR_INVALID_ENTRY' | 'ERR_INVALID_RANGE' | 'ERR_RESOURCE_LIMIT' | 'ERR_ARCHIVE_OPEN' | 'ERR_ARCHIVE_PASSWORD' | 'ERR_ARCHIVE_PATH' | 'ERR_ARCHIVE_EXTRACT' | 'ERR_ARCHIVE_CREATE';
 declare class ArchiveError extends Error {
     readonly code: ArchiveErrorCode;
     constructor(code: ArchiveErrorCode, message: string, options?: ErrorOptions);
@@ -52,6 +68,7 @@ declare class Archive {
     private constructor();
     static concurrency(value?: number): number;
     static open(path: string, options?: OpenOptions): Promise<Archive>;
+    static create(outputPath: string, entries: readonly ArchiveCreateEntry[], options?: CreateArchiveOptions): Promise<void>;
     entries(): Promise<readonly ArchiveEntry[]>;
     getEntry(idOrPath: EntrySelector): Promise<ArchiveEntry | undefined>;
     extract(idOrPath: EntrySelector): Promise<Buffer>;
@@ -69,4 +86,4 @@ declare class Archive {
 }
 
 export { Archive, ArchiveError };
-export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, ExtractToFolderProgress, OpenOptions, ReadOptions, ReadStreamOptions };
+export type { ArchiveCreateEntry, ArchiveEntry, ArchiveErrorCode, ArchiveFormat, CreateArchiveOptions, EntryId, EntrySelector, ExtractToFolderOptions, ExtractToFolderProgress, ExtractedArchiveFile, OpenOptions, ReadOptions, ReadStreamOptions };

package/dist/index.d.mts

@@ -19,6 +19,16 @@ interface ReadOptions {
 interface OpenOptions {
     readonly password?: string;
 }
+type ArchiveFormat = '7z' | 'zip' | 'tar' | 'wim';
+interface ArchiveCreateEntry {
+    readonly sourcePath: string;
+    readonly path: string;
+}
+interface CreateArchiveOptions {
+    readonly format?: ArchiveFormat;
+    readonly compressionLevel?: number;
+    readonly overwrite?: boolean;
+}
 interface ExtractToFolderProgress {
     readonly filesExtracted: number;
     readonly totalFiles: number;
@@ -26,6 +36,10 @@ interface ExtractToFolderProgress {
     readonly totalBytes: bigint;
     readonly percent: number;
 }
+interface ExtractedArchiveFile {
+    readonly entry: ArchiveEntry;
+    readonly outputPath: string;
+}
 interface ReadStreamOptions {
     readonly highWaterMark?: number;
     readonly maxBytes?: number | bigint | null;
@@ -34,12 +48,14 @@ interface ReadStreamOptions {
 interface ExtractToFolderOptions {
     readonly ids?: readonly EntryId[];
     readonly paths?: readonly string[];
+    readonly concurrency?: number;
     readonly overwrite?: boolean;
     readonly onProgress?: (progress: ExtractToFolderProgress) => void;
+    readonly onExtract?: (result: ExtractedArchiveFile) => void;
     readonly maxBytes?: number | bigint | null;
     readonly signal?: AbortSignal;
 }
-type ArchiveErrorCode = 'ERR_ARCHIVE_CLOSED' | 'ERR_INVALID_ENTRY' | 'ERR_INVALID_RANGE' | 'ERR_RESOURCE_LIMIT' | 'ERR_ARCHIVE_OPEN' | 'ERR_ARCHIVE_PASSWORD' | 'ERR_ARCHIVE_PATH' | 'ERR_ARCHIVE_EXTRACT';
+type ArchiveErrorCode = 'ERR_ARCHIVE_CLOSED' | 'ERR_INVALID_ENTRY' | 'ERR_INVALID_RANGE' | 'ERR_RESOURCE_LIMIT' | 'ERR_ARCHIVE_OPEN' | 'ERR_ARCHIVE_PASSWORD' | 'ERR_ARCHIVE_PATH' | 'ERR_ARCHIVE_EXTRACT' | 'ERR_ARCHIVE_CREATE';
 declare class ArchiveError extends Error {
     readonly code: ArchiveErrorCode;
     constructor(code: ArchiveErrorCode, message: string, options?: ErrorOptions);
@@ -52,6 +68,7 @@ declare class Archive {
     private constructor();
     static concurrency(value?: number): number;
     static open(path: string, options?: OpenOptions): Promise<Archive>;
+    static create(outputPath: string, entries: readonly ArchiveCreateEntry[], options?: CreateArchiveOptions): Promise<void>;
     entries(): Promise<readonly ArchiveEntry[]>;
     getEntry(idOrPath: EntrySelector): Promise<ArchiveEntry | undefined>;
     extract(idOrPath: EntrySelector): Promise<Buffer>;
@@ -69,4 +86,4 @@ declare class Archive {
 }
 
 export { Archive, ArchiveError };
-export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, ExtractToFolderProgress, OpenOptions, ReadOptions, ReadStreamOptions };
+export type { ArchiveCreateEntry, ArchiveEntry, ArchiveErrorCode, ArchiveFormat, CreateArchiveOptions, EntryId, EntrySelector, ExtractToFolderOptions, ExtractToFolderProgress, ExtractedArchiveFile, OpenOptions, ReadOptions, ReadStreamOptions };

package/dist/index.d.ts

@@ -19,6 +19,16 @@ interface ReadOptions {
 interface OpenOptions {
     readonly password?: string;
 }
+type ArchiveFormat = '7z' | 'zip' | 'tar' | 'wim';
+interface ArchiveCreateEntry {
+    readonly sourcePath: string;
+    readonly path: string;
+}
+interface CreateArchiveOptions {
+    readonly format?: ArchiveFormat;
+    readonly compressionLevel?: number;
+    readonly overwrite?: boolean;
+}
 interface ExtractToFolderProgress {
     readonly filesExtracted: number;
     readonly totalFiles: number;
@@ -26,6 +36,10 @@ interface ExtractToFolderProgress {
     readonly totalBytes: bigint;
     readonly percent: number;
 }
+interface ExtractedArchiveFile {
+    readonly entry: ArchiveEntry;
+    readonly outputPath: string;
+}
 interface ReadStreamOptions {
     readonly highWaterMark?: number;
     readonly maxBytes?: number | bigint | null;
@@ -34,12 +48,14 @@ interface ReadStreamOptions {
 interface ExtractToFolderOptions {
     readonly ids?: readonly EntryId[];
     readonly paths?: readonly string[];
+    readonly concurrency?: number;
     readonly overwrite?: boolean;
     readonly onProgress?: (progress: ExtractToFolderProgress) => void;
+    readonly onExtract?: (result: ExtractedArchiveFile) => void;
     readonly maxBytes?: number | bigint | null;
     readonly signal?: AbortSignal;
 }
-type ArchiveErrorCode = 'ERR_ARCHIVE_CLOSED' | 'ERR_INVALID_ENTRY' | 'ERR_INVALID_RANGE' | 'ERR_RESOURCE_LIMIT' | 'ERR_ARCHIVE_OPEN' | 'ERR_ARCHIVE_PASSWORD' | 'ERR_ARCHIVE_PATH' | 'ERR_ARCHIVE_EXTRACT';
+type ArchiveErrorCode = 'ERR_ARCHIVE_CLOSED' | 'ERR_INVALID_ENTRY' | 'ERR_INVALID_RANGE' | 'ERR_RESOURCE_LIMIT' | 'ERR_ARCHIVE_OPEN' | 'ERR_ARCHIVE_PASSWORD' | 'ERR_ARCHIVE_PATH' | 'ERR_ARCHIVE_EXTRACT' | 'ERR_ARCHIVE_CREATE';
 declare class ArchiveError extends Error {
     readonly code: ArchiveErrorCode;
     constructor(code: ArchiveErrorCode, message: string, options?: ErrorOptions);
@@ -52,6 +68,7 @@ declare class Archive {
     private constructor();
     static concurrency(value?: number): number;
     static open(path: string, options?: OpenOptions): Promise<Archive>;
+    static create(outputPath: string, entries: readonly ArchiveCreateEntry[], options?: CreateArchiveOptions): Promise<void>;
     entries(): Promise<readonly ArchiveEntry[]>;
     getEntry(idOrPath: EntrySelector): Promise<ArchiveEntry | undefined>;
     extract(idOrPath: EntrySelector): Promise<Buffer>;
@@ -69,4 +86,4 @@ declare class Archive {
 }
 
 export { Archive, ArchiveError };
-export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, ExtractToFolderProgress, OpenOptions, ReadOptions, ReadStreamOptions };
+export type { ArchiveCreateEntry, ArchiveEntry, ArchiveErrorCode, ArchiveFormat, CreateArchiveOptions, EntryId, EntrySelector, ExtractToFolderOptions, ExtractToFolderProgress, ExtractedArchiveFile, OpenOptions, ReadOptions, ReadStreamOptions };