7zip-native 0.0.0-stage → 0.0.5

package/dist/index.cjs

@@ -0,0 +1,528 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var promises$1 = require('node:fs/promises');
+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 _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+class ArchiveError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = 'ArchiveError';
+    }
+}
+
+const defaultMaxOutputBytes = 4n * 1024n * 1024n * 1024n;
+function normalizeMaxBytes(value, label) {
+    if (value === undefined) {
+        return defaultMaxOutputBytes;
+    }
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === 'bigint') {
+        if (value < 0n) {
+            throw new RangeError(`${label} must be non-negative`);
+        }
+        return value;
+    }
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${label} must be a non-negative safe integer or bigint`);
+    }
+    return BigInt(value);
+}
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+let engineName = '7z.so';
+if (process.platform === 'win32') {
+    engineName = '7z.dll';
+}
+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 runtimeDirectory = [
+    node_path.resolve(packageDirectory, `../prebuilds/${process.platform}-${process.arch}`),
+    node_path.resolve(packageDirectory, '../build/Release'),
+].find(directory => node_fs.existsSync(node_path.join(directory, '7zip_native.node')) && node_fs.existsSync(node_path.join(directory, engineName)));
+if (!runtimeDirectory) {
+    throw new Error(`Native binaries for ${process.platform}-${process.arch} were not found; build 7zip-native from source`);
+}
+const enginePath = node_path.join(runtimeDirectory, engineName);
+const native = require$1(node_path.join(runtimeDirectory, '7zip_native.node'));
+const defaultConcurrency = Math.max(1, Math.min(node_os.availableParallelism(), 4));
+native.concurrency(defaultConcurrency);
+function safeEntrySegments(entryPath) {
+    if (entryPath.includes('\0')) {
+        throw new ArchiveError('ERR_ARCHIVE_PATH', 'Archive entry path contains a null byte');
+    }
+    const normalized = entryPath.replace(/\\/g, '/');
+    if (normalized.startsWith('/') || /^[a-zA-Z]:/.test(normalized)) {
+        throw new ArchiveError('ERR_ARCHIVE_PATH', `Archive entry path is absolute: ${entryPath}`);
+    }
+    const segments = normalized.split('/').filter(segment => segment !== '' && segment !== '.');
+    if (segments.length === 0 || segments.some(segment => segment === '..'
+        || segment.includes(':')
+        || /[. ]$/.test(segment)
+        || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(segment))) {
+        throw new ArchiveError('ERR_ARCHIVE_PATH', `Unsafe archive entry path: ${entryPath}`);
+    }
+    return segments;
+}
+function makeOutputPlans(root, entries) {
+    const caseInsensitivePaths = process.platform === 'win32' || process.platform === 'darwin';
+    const plans = entries.map((entry) => {
+        const segments = safeEntrySegments(entry.path);
+        const targetPath = node_path.resolve(root, ...segments);
+        const relative = node_path.relative(root, targetPath);
+        if (relative === ''
+            || relative === '..'
+            || relative.startsWith(`..${node_path.sep}`)
+            || node_path.resolve(root, relative) !== targetPath) {
+            throw new ArchiveError('ERR_ARCHIVE_PATH', `Archive entry escapes the destination: ${entry.path}`);
+        }
+        return { entry, segments, targetPath, isDirectory: entry.isDirectory };
+    });
+    const pathKinds = new Map();
+    for (const plan of plans) {
+        const relative = node_path.relative(root, plan.targetPath).split(node_path.sep).join('/');
+        const key = caseInsensitivePaths ? relative.toLowerCase() : relative;
+        if (pathKinds.has(key)) {
+            throw new ArchiveError('ERR_ARCHIVE_PATH', `Archive contains colliding paths: ${plan.entry.path}`);
+        }
+        pathKinds.set(key, plan.isDirectory);
+    }
+    for (const plan of plans) {
+        let parent = '';
+        for (const segment of plan.segments.slice(0, -1)) {
+            parent = parent ? `${parent}/${segment}` : segment;
+            const key = caseInsensitivePaths ? parent.toLowerCase() : parent;
+            if (pathKinds.get(key) === false) {
+                throw new ArchiveError('ERR_ARCHIVE_PATH', `Archive path traverses a non-directory entry: ${plan.entry.path}`);
+            }
+        }
+    }
+    return plans;
+}
+async function ensureDirectory(directoryPath) {
+    try {
+        await promises$1.mkdir(directoryPath, { mode: 0o700 });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+    const details = await promises$1.lstat(directoryPath);
+    if (details.isSymbolicLink() || !details.isDirectory()) {
+        throw new ArchiveError('ERR_ARCHIVE_PATH', `Destination path is not a real directory: ${directoryPath}`);
+    }
+}
+async function ensureExtractionRoot(root) {
+    try {
+        const details = await promises$1.lstat(root);
+        if (details.isSymbolicLink() || !details.isDirectory()) {
+            throw new ArchiveError('ERR_ARCHIVE_PATH', `Destination is not a real directory: ${root}`);
+        }
+        return;
+    }
+    catch (error) {
+        if (error instanceof ArchiveError || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await promises$1.mkdir(root, { recursive: true, mode: 0o700 });
+    const details = await promises$1.lstat(root);
+    if (details.isSymbolicLink() || !details.isDirectory()) {
+        throw new ArchiveError('ERR_ARCHIVE_PATH', `Destination is not a real directory: ${root}`);
+    }
+}
+async function ensureOutputParents(root, targetPath) {
+    const parent = node_path.relative(root, targetPath);
+    const segments = parent ? parent.split(node_path.sep).slice(0, -1) : [];
+    let current = root;
+    for (const segment of segments) {
+        current = node_path.join(current, segment);
+        await ensureDirectory(current);
+    }
+}
+async function ensureOutputDirectoryTree(root, directoryPath) {
+    const relative = node_path.relative(root, directoryPath);
+    let current = root;
+    for (const segment of relative.split(node_path.sep)) {
+        current = node_path.join(current, segment);
+        await ensureDirectory(current);
+    }
+}
+class NativeArchiveReadable extends node_stream.Readable {
+    start;
+    resumeNative;
+    cancel;
+    maxBytes;
+    streamId;
+    outputBytes = 0n;
+    starting = false;
+    constructor(start, resumeNative, cancel, options, maxBytes) {
+        super({ highWaterMark: options.highWaterMark, signal: options.signal });
+        this.start = start;
+        this.resumeNative = resumeNative;
+        this.cancel = cancel;
+        this.maxBytes = maxBytes;
+    }
+    _read() {
+        if (this.streamId !== undefined) {
+            try {
+                this.resumeNative(this.streamId);
+            }
+            catch (cause) {
+                this.destroy(extractionError(cause));
+            }
+            return;
+        }
+        if (this.starting) {
+            return;
+        }
+        this.starting = true;
+        try {
+            Promise.resolve(this.start((chunk, error, done) => {
+                if (this.destroyed) {
+                    return;
+                }
+                if (error) {
+                    this.destroy(extractionError(error));
+                }
+                else if (done) {
+                    this.push(null);
+                }
+                else if (chunk) {
+                    if (this.maxBytes !== null
+                        && this.outputBytes + BigInt(chunk.length) > this.maxBytes) {
+                        this.destroy(new ArchiveError('ERR_RESOURCE_LIMIT', `Stream output exceeds the ${this.maxBytes}-byte limit`));
+                        return;
+                    }
+                    this.outputBytes += BigInt(chunk.length);
+                    this.push(chunk);
+                }
+                else {
+                    this.destroy(new ArchiveError('ERR_ARCHIVE_EXTRACT', 'Native stream returned an empty chunk notification'));
+                }
+            })).then((streamId) => {
+                this.streamId = streamId;
+                this.starting = false;
+                try {
+                    if (this.destroyed) {
+                        this.cancel(streamId);
+                    }
+                    else {
+                        this.resumeNative(streamId);
+                    }
+                }
+                catch (cause) {
+                    this.destroy(extractionError(cause));
+                }
+            }, (cause) => {
+                this.starting = false;
+                this.destroy(extractionError(cause));
+            });
+        }
+        catch (cause) {
+            this.starting = false;
+            this.destroy(extractionError(cause));
+        }
+    }
+    _destroy(error, callback) {
+        try {
+            if (this.streamId !== undefined) {
+                this.cancel(this.streamId);
+            }
+            callback(error);
+        }
+        catch (cause) {
+            callback(error ?? extractionError(cause));
+        }
+    }
+}
+class Archive {
+    handle;
+    closed = false;
+    entriesPromise;
+    constructor(handle) {
+        this.handle = handle;
+    }
+    static concurrency(value) {
+        if (value === undefined) {
+            return native.concurrency();
+        }
+        if (!Number.isSafeInteger(value) || value < 0 || value > 128) {
+            throw new RangeError('Concurrency must be 0 (default) or an integer between 1 and 128');
+        }
+        return native.concurrency(value === 0 ? defaultConcurrency : value);
+    }
+    static async open(path, options = {}) {
+        if (typeof path !== 'string' || path.length === 0) {
+            throw new TypeError('Archive path must be a non-empty string');
+        }
+        if (options.password !== undefined) {
+            if (typeof options.password !== 'string') {
+                throw new TypeError('Archive password must be a string');
+            }
+            if (Buffer.byteLength(options.password, 'utf8') > 1024 * 1024) {
+                throw new RangeError('Password exceeds the 1 MiB native password limit');
+            }
+        }
+        try {
+            const handle = await native.open(node_path.resolve(path), options.password, enginePath);
+            return new Archive(handle);
+        }
+        catch (cause) {
+            const message = errorMessage(cause);
+            throw new ArchiveError(/password/i.test(message) ? 'ERR_ARCHIVE_PASSWORD' : 'ERR_ARCHIVE_OPEN', message, { cause });
+        }
+    }
+    async entries() {
+        this.assertOpen();
+        this.entriesPromise ??= native.entries(this.handle).catch((cause) => {
+            throw new ArchiveError('ERR_ARCHIVE_OPEN', errorMessage(cause), { cause });
+        });
+        return this.entriesPromise;
+    }
+    async getEntry(idOrPath) {
+        if (typeof idOrPath === 'number' && (!Number.isSafeInteger(idOrPath) || idOrPath < 0)) {
+            throw new RangeError('Entry ID must be a non-negative safe integer');
+        }
+        return (await this.entries()).find(entry => typeof idOrPath === 'number' ? entry.id === idOrPath : entry.path === idOrPath);
+    }
+    async extract(idOrPathOrPaths) {
+        this.assertOpen();
+        const isBatch = Array.isArray(idOrPathOrPaths);
+        let selectors;
+        if (isBatch) {
+            selectors = idOrPathOrPaths;
+        }
+        else {
+            selectors = [idOrPathOrPaths];
+        }
+        const numericIds = selectors.filter((selector) => typeof selector === 'number');
+        let ids;
+        if (numericIds.length === selectors.length) {
+            this.validateIds(numericIds);
+            ids = numericIds;
+        }
+        else {
+            ids = await this.resolveEntryIds(selectors);
+        }
+        try {
+            const buffers = await native.extract(this.handle, ids);
+            return isBatch ? buffers : buffers[0];
+        }
+        catch (cause) {
+            throw extractionError(cause);
+        }
+    }
+    createReadStream(idOrPath, options = {}) {
+        this.assertOpen();
+        if (typeof idOrPath === 'number') {
+            this.validateIds([idOrPath]);
+        }
+        else if (typeof idOrPath !== 'string') {
+            throw new TypeError('Entry selector must be an ID or archive path');
+        }
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('Stream options must be an object');
+        }
+        if (options.highWaterMark !== undefined
+            && (!Number.isSafeInteger(options.highWaterMark)
+                || options.highWaterMark < 1
+                || options.highWaterMark > 16 * 1024 * 1024)) {
+            throw new RangeError('highWaterMark must be an integer between 1 byte and 16 MiB');
+        }
+        options.signal?.throwIfAborted();
+        const maxBytes = normalizeMaxBytes(options.maxBytes, 'maxBytes');
+        return new NativeArchiveReadable((callback) => {
+            if (typeof idOrPath === 'number') {
+                return native.startStream(this.handle, idOrPath, callback);
+            }
+            return this.resolveEntryId(idOrPath).then(id => native.startStream(this.handle, id, callback));
+        }, streamId => native.resumeStream(streamId), streamId => native.cancelStream(streamId), options, maxBytes);
+    }
+    async extractToStream(idOrPath, destination, options = {}) {
+        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 });
+    }
+    async extractToFolder(destination, options = {}) {
+        this.assertOpen();
+        if (typeof destination !== 'string' || destination.length === 0) {
+            throw new TypeError('Destination folder must be a non-empty path');
+        }
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('Folder extraction options must be an object');
+        }
+        options.signal?.throwIfAborted();
+        const maxBytes = normalizeMaxBytes(options.maxBytes, 'maxBytes');
+        const entries = await this.entries();
+        let selectedEntries = entries;
+        if (options.ids !== undefined && options.paths !== undefined) {
+            throw new TypeError('Specify either folder extraction IDs or paths, not both');
+        }
+        if (options.ids !== undefined) {
+            if (!Array.isArray(options.ids)) {
+                throw new TypeError('Folder extraction IDs must be an array');
+            }
+            this.validateIds(options.ids);
+            const entriesById = new Map(entries.map(entry => [entry.id, entry]));
+            selectedEntries = options.ids.map((id) => {
+                const entry = entriesById.get(id);
+                if (!entry) {
+                    throw new ArchiveError('ERR_INVALID_ENTRY', `Entry ID ${id} is out of range`);
+                }
+                return entry;
+            });
+        }
+        else if (options.paths !== undefined) {
+            if (!Array.isArray(options.paths)
+                || options.paths.some(entryPath => typeof entryPath !== 'string')) {
+                throw new TypeError('Folder extraction paths must be an array of strings');
+            }
+            const ids = await this.resolveEntryIds(options.paths);
+            const entriesById = new Map(entries.map(entry => [entry.id, entry]));
+            selectedEntries = ids.map((id) => {
+                const entry = entriesById.get(id);
+                if (!entry) {
+                    throw new ArchiveError('ERR_INVALID_ENTRY', `Entry ID ${id} is out of range`);
+                }
+                return entry;
+            });
+        }
+        const root = node_path.resolve(destination);
+        const plans = makeOutputPlans(root, selectedEntries);
+        const expectedBytes = selectedEntries.reduce((total, entry) => total + (entry.isDirectory ? 0n : entry.size), 0n);
+        if (maxBytes !== null && expectedBytes > maxBytes) {
+            throw new ArchiveError('ERR_RESOURCE_LIMIT', `Folder output exceeds the ${maxBytes}-byte limit`);
+        }
+        options.signal?.throwIfAborted();
+        await ensureExtractionRoot(root);
+        let extractedBytes = 0n;
+        for (const plan of plans) {
+            options.signal?.throwIfAborted();
+            if (plan.isDirectory) {
+                await ensureOutputDirectoryTree(root, plan.targetPath);
+                continue;
+            }
+            await ensureOutputParents(root, plan.targetPath);
+            const output = node_fs.createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 });
+            const limit = new node_stream.Transform({
+                transform(chunk, _encoding, callback) {
+                    const size = BigInt(chunk.length);
+                    if (maxBytes !== null && extractedBytes + size > maxBytes) {
+                        callback(new ArchiveError('ERR_RESOURCE_LIMIT', `Folder output exceeds the ${maxBytes}-byte limit`));
+                        return;
+                    }
+                    extractedBytes += size;
+                    callback(null, chunk);
+                },
+            });
+            await promises.pipeline(this.createReadStream(plan.entry.id, {
+                signal: options.signal,
+                maxBytes: null,
+            }), limit, output, { signal: options.signal });
+        }
+    }
+    async read(idOrPath, options) {
+        this.assertOpen();
+        let id;
+        if (typeof idOrPath === 'number') {
+            this.validateIds([idOrPath]);
+            id = idOrPath;
+        }
+        else {
+            id = await this.resolveEntryId(idOrPath);
+        }
+        const offset = this.toUnsignedBigInt(options.offset ?? 0, 'offset');
+        const length = this.toUnsignedBigInt(options.length, 'length');
+        const maxUInt64 = (1n << 64n) - 1n;
+        if (offset > maxUInt64 || length > maxUInt64 - offset) {
+            throw new ArchiveError('ERR_INVALID_RANGE', 'Read range exceeds the native 64-bit offset limit');
+        }
+        try {
+            return await native.read(this.handle, id, offset, length);
+        }
+        catch (cause) {
+            throw extractionError(cause);
+        }
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        native.close(this.handle);
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new ArchiveError('ERR_ARCHIVE_CLOSED', 'Archive is closed');
+        }
+    }
+    validateIds(ids) {
+        if (ids.some(id => !Number.isSafeInteger(id) || id < 0) || new Set(ids).size !== ids.length) {
+            throw new ArchiveError('ERR_INVALID_ENTRY', 'Entry IDs must be unique non-negative safe integers');
+        }
+    }
+    async resolveEntryId(selector) {
+        if (typeof selector === 'number') {
+            this.validateIds([selector]);
+            return selector;
+        }
+        if (typeof selector !== 'string') {
+            throw new TypeError('Entry selector must be an ID or archive path');
+        }
+        const entry = await this.getEntry(selector);
+        if (!entry) {
+            throw new ArchiveError('ERR_INVALID_ENTRY', `Archive entry "${selector}" was not found`);
+        }
+        return entry.id;
+    }
+    async resolveEntryIds(selectors) {
+        const ids = await Promise.all(selectors.map(selector => this.resolveEntryId(selector)));
+        this.validateIds(ids);
+        return ids;
+    }
+    toUnsignedBigInt(value, label) {
+        if (typeof value === 'bigint') {
+            if (value < 0n) {
+                throw new RangeError(`${label} must be non-negative`);
+            }
+            return value;
+        }
+        if (!Number.isSafeInteger(value) || value < 0) {
+            throw new RangeError(`${label} must be a non-negative safe integer or bigint`);
+        }
+        return BigInt(value);
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function extractionError(cause) {
+    const message = errorMessage(cause);
+    if (/password/i.test(message)) {
+        return new ArchiveError('ERR_ARCHIVE_PASSWORD', message, { cause });
+    }
+    if (/Entry ID is out of range|Cannot read a directory|Duplicate entry IDs/i.test(message)) {
+        return new ArchiveError('ERR_INVALID_ENTRY', message, { cause });
+    }
+    if (/in-memory output limit|queue is full/i.test(message)) {
+        return new ArchiveError('ERR_RESOURCE_LIMIT', message, { cause });
+    }
+    return new ArchiveError('ERR_ARCHIVE_EXTRACT', message, { cause });
+}
+
+exports.Archive = Archive;
+exports.ArchiveError = ArchiveError;

package/dist/index.d.cts

@@ -0,0 +1,63 @@
+import { Readable, Writable } from 'node:stream';
+
+type EntryId = number;
+type EntrySelector = EntryId | string;
+interface ArchiveEntry {
+    readonly id: EntryId;
+    readonly path: string;
+    readonly size: bigint;
+    readonly compressedSize: bigint;
+    readonly isDirectory: boolean;
+    readonly encrypted: boolean;
+    readonly attributes: number;
+    readonly crc?: number;
+}
+interface ReadOptions {
+    readonly offset?: number | bigint;
+    readonly length: number | bigint;
+}
+interface OpenOptions {
+    readonly password?: string;
+}
+interface ReadStreamOptions {
+    readonly highWaterMark?: number;
+    readonly maxBytes?: number | bigint | null;
+    readonly signal?: AbortSignal;
+}
+interface ExtractToFolderOptions {
+    readonly ids?: readonly EntryId[];
+    readonly paths?: readonly string[];
+    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';
+declare class ArchiveError extends Error {
+    readonly code: ArchiveErrorCode;
+    constructor(code: ArchiveErrorCode, message: string, options?: ErrorOptions);
+}
+
+declare class Archive {
+    private readonly handle;
+    private closed;
+    private entriesPromise?;
+    private constructor();
+    static concurrency(value?: number): number;
+    static open(path: string, options?: OpenOptions): Promise<Archive>;
+    entries(): Promise<readonly ArchiveEntry[]>;
+    getEntry(idOrPath: EntrySelector): Promise<ArchiveEntry | undefined>;
+    extract(idOrPath: EntrySelector): Promise<Buffer>;
+    extract(idsOrPaths: readonly EntrySelector[]): Promise<Buffer[]>;
+    createReadStream(idOrPath: EntrySelector, options?: ReadStreamOptions): Readable;
+    extractToStream(idOrPath: EntrySelector, destination: Writable, options?: ReadStreamOptions): Promise<void>;
+    extractToFolder(destination: string, options?: ExtractToFolderOptions): Promise<void>;
+    read(idOrPath: EntrySelector, options: ReadOptions): Promise<Buffer>;
+    close(): Promise<void>;
+    private assertOpen;
+    private validateIds;
+    private resolveEntryId;
+    private resolveEntryIds;
+    private toUnsignedBigInt;
+}
+
+export { Archive, ArchiveError };
+export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, OpenOptions, ReadOptions, ReadStreamOptions };

package/dist/index.d.mts

@@ -0,0 +1,63 @@
+import { Readable, Writable } from 'node:stream';
+
+type EntryId = number;
+type EntrySelector = EntryId | string;
+interface ArchiveEntry {
+    readonly id: EntryId;
+    readonly path: string;
+    readonly size: bigint;
+    readonly compressedSize: bigint;
+    readonly isDirectory: boolean;
+    readonly encrypted: boolean;
+    readonly attributes: number;
+    readonly crc?: number;
+}
+interface ReadOptions {
+    readonly offset?: number | bigint;
+    readonly length: number | bigint;
+}
+interface OpenOptions {
+    readonly password?: string;
+}
+interface ReadStreamOptions {
+    readonly highWaterMark?: number;
+    readonly maxBytes?: number | bigint | null;
+    readonly signal?: AbortSignal;
+}
+interface ExtractToFolderOptions {
+    readonly ids?: readonly EntryId[];
+    readonly paths?: readonly string[];
+    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';
+declare class ArchiveError extends Error {
+    readonly code: ArchiveErrorCode;
+    constructor(code: ArchiveErrorCode, message: string, options?: ErrorOptions);
+}
+
+declare class Archive {
+    private readonly handle;
+    private closed;
+    private entriesPromise?;
+    private constructor();
+    static concurrency(value?: number): number;
+    static open(path: string, options?: OpenOptions): Promise<Archive>;
+    entries(): Promise<readonly ArchiveEntry[]>;
+    getEntry(idOrPath: EntrySelector): Promise<ArchiveEntry | undefined>;
+    extract(idOrPath: EntrySelector): Promise<Buffer>;
+    extract(idsOrPaths: readonly EntrySelector[]): Promise<Buffer[]>;
+    createReadStream(idOrPath: EntrySelector, options?: ReadStreamOptions): Readable;
+    extractToStream(idOrPath: EntrySelector, destination: Writable, options?: ReadStreamOptions): Promise<void>;
+    extractToFolder(destination: string, options?: ExtractToFolderOptions): Promise<void>;
+    read(idOrPath: EntrySelector, options: ReadOptions): Promise<Buffer>;
+    close(): Promise<void>;
+    private assertOpen;
+    private validateIds;
+    private resolveEntryId;
+    private resolveEntryIds;
+    private toUnsignedBigInt;
+}
+
+export { Archive, ArchiveError };
+export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, OpenOptions, ReadOptions, ReadStreamOptions };