dir-archiver 2.2.0 → 3.0.0

package/dist/core.js

@@ -0,0 +1,549 @@
+import { createReadStream, createWriteStream, existsSync, promises as fsPromises, statSync } from 'node:fs';
+import path from 'node:path';
+import { Readable, Writable } from 'node:stream';
+import { DirArchiverError } from './errors.js';
+import { loadRuntimeBindings } from './runtime/index.js';
+const DIRECTORY_TO_SINGLE_FILE_CODEC = {
+    gz: 'tar.gz',
+    bz2: 'tar.bz2',
+    xz: 'tar.xz',
+    zst: 'tar.zst',
+    br: 'tar.br'
+};
+const writeUnsupportedFormats = new Set(['tar.bz2', 'bz2', 'tar.xz', 'xz']);
+/**
+ * Opens an archive input with bytefold runtime bindings.
+ */
+export const open = async (input, options = {}) => {
+    const runtime = await loadRuntimeBindings();
+    return runtime.openArchive(input, toArchiveOpenOptions(options));
+};
+/**
+ * Detects archive format and exposes bytefold detection metadata.
+ */
+export const detect = async (input, options = {}) => {
+    const reader = await open(input, options);
+    try {
+        return {
+            format: reader.format,
+            detection: reader.detection
+        };
+    }
+    finally {
+        await disposeArchiveReader(reader);
+    }
+};
+/**
+ * Lists archive entries without extracting to disk.
+ */
+export const list = async (input, options = {}) => {
+    const reader = await open(input, options);
+    try {
+        const entries = [];
+        for await (const entry of reader.entries()) {
+            entries.push({
+                format: entry.format,
+                name: entry.name,
+                size: entry.size.toString(),
+                isDirectory: entry.isDirectory,
+                isSymlink: entry.isSymlink,
+                ...(typeof entry.linkName === 'string' ? { linkName: entry.linkName } : {})
+            });
+        }
+        return {
+            format: reader.format,
+            detection: reader.detection,
+            entries
+        };
+    }
+    finally {
+        await disposeArchiveReader(reader);
+    }
+};
+/**
+ * Runs bytefold audit checks for the selected safety profile.
+ */
+export const audit = async (input, options = {}) => {
+    const reader = await open(input, options);
+    try {
+        return await reader.audit(toAuditOptions(options));
+    }
+    finally {
+        await disposeArchiveReader(reader);
+    }
+};
+/**
+ * Writes a normalized deterministic archive when supported by the format.
+ */
+export const normalize = async (input, destination, options = {}) => {
+    const reader = await open(input, options);
+    try {
+        if (typeof reader.normalizeToWritable !== 'function') {
+            throw new DirArchiverError('DIRARCHIVER_NORMALIZE_UNSUPPORTED', `Normalize is unavailable for format "${reader.format}".`);
+        }
+        const destinationPath = path.resolve(destination);
+        await ensureParentDirectory(destinationPath);
+        const writable = createFileWritable(destinationPath);
+        const report = await reader.normalizeToWritable(writable, toNormalizeOptions(options));
+        return {
+            format: reader.format,
+            report
+        };
+    }
+    finally {
+        await disposeArchiveReader(reader);
+    }
+};
+/**
+ * Extracts entries to a destination directory with safety enforcement.
+ */
+export const extract = async (input, destination, options = {}) => {
+    var _a;
+    const reader = await open(input, options);
+    try {
+        const profile = (_a = options.profile) !== null && _a !== void 0 ? _a : 'strict';
+        const issues = [];
+        const destinationRoot = path.resolve(destination);
+        await fsPromises.mkdir(destinationRoot, { recursive: true });
+        if (profile !== 'compat') {
+            if (profile === 'agent') {
+                try {
+                    await reader.assertSafe(toAuditOptions({
+                        ...options,
+                        profile
+                    }));
+                }
+                catch (error) {
+                    throw new DirArchiverError('DIRARCHIVER_UNSUPPORTED_ENTRY', 'Archive assertSafe failed under agent safety profile.', { cause: error });
+                }
+            }
+            const auditReport = await reader.audit(toAuditOptions({
+                ...options,
+                profile
+            }));
+            if (!auditReport.ok) {
+                const hasTraversalIssue = auditReport.issues.some((issue) => issue.code.includes('TRAVERSAL')
+                    || issue.code.includes('ABSOLUTE'));
+                throw new DirArchiverError(hasTraversalIssue ? 'DIRARCHIVER_PATH_TRAVERSAL' : 'DIRARCHIVER_UNSUPPORTED_ENTRY', 'Archive audit failed under strict safety profile.', {
+                    context: {
+                        issues: auditReport.issues
+                    }
+                });
+            }
+            issues.push(...auditReport.issues);
+        }
+        let extractedFiles = 0;
+        let extractedDirectories = 0;
+        let skippedEntries = 0;
+        let totalExtractedBytes = 0;
+        for await (const entry of reader.entries()) {
+            const destinationPath = resolveEntryDestination(destinationRoot, entry.name);
+            if (entry.isDirectory) {
+                await fsPromises.mkdir(destinationPath, { recursive: true });
+                extractedDirectories += 1;
+                continue;
+            }
+            if (entry.isSymlink) {
+                if (options.allowSymlinks !== true) {
+                    skippedEntries += 1;
+                    continue;
+                }
+                if (typeof entry.linkName !== 'string' || entry.linkName.length === 0) {
+                    throw new DirArchiverError('DIRARCHIVER_UNSUPPORTED_ENTRY', `Symlink "${entry.name}" is missing a link target.`);
+                }
+                const symlinkTarget = normalizeSymlinkTarget(entry.linkName);
+                await ensureParentDirectory(destinationPath);
+                await fsPromises.symlink(symlinkTarget, destinationPath);
+                continue;
+            }
+            if (typeof entry.linkName === 'string' && entry.linkName.length > 0) {
+                throw new DirArchiverError('DIRARCHIVER_UNSUPPORTED_ENTRY', `Hard link entry "${entry.name}" is not supported by dir-archiver v3.`);
+            }
+            const stream = await entry.open();
+            const bytes = await readAllBytes(stream, options.maxEntryBytes, options.maxTotalExtractedBytes, totalExtractedBytes);
+            totalExtractedBytes += bytes.length;
+            await ensureParentDirectory(destinationPath);
+            await fsPromises.writeFile(destinationPath, bytes);
+            extractedFiles += 1;
+        }
+        return {
+            format: reader.format,
+            destination: destinationRoot,
+            extractedFiles,
+            extractedDirectories,
+            skippedEntries,
+            issues
+        };
+    }
+    finally {
+        await disposeArchiveReader(reader);
+    }
+};
+/**
+ * Writes an archive from a file or directory source.
+ */
+export const write = async (source, destination, options = {}) => {
+    var _a, _b;
+    const runtime = await loadRuntimeBindings();
+    const sourcePath = path.resolve(source);
+    const destinationPath = path.resolve(destination);
+    const requestedFormat = (_b = (_a = options.format) !== null && _a !== void 0 ? _a : inferFormatFromDestination(destinationPath)) !== null && _b !== void 0 ? _b : 'zip';
+    const sourceStats = await fsPromises.lstat(sourcePath);
+    const sourceIsDirectory = sourceStats.isDirectory();
+    const wrappedFormat = sourceIsDirectory
+        ? DIRECTORY_TO_SINGLE_FILE_CODEC[requestedFormat]
+        : undefined;
+    const wrappedDirectoryCodec = typeof wrappedFormat === 'string';
+    const outputFormat = wrappedFormat !== null && wrappedFormat !== void 0 ? wrappedFormat : requestedFormat;
+    if (writeUnsupportedFormats.has(outputFormat)) {
+        throw new DirArchiverError('DIRARCHIVER_UNSUPPORTED_ENTRY', `Write format "${outputFormat}" is unsupported by bytefold writers.`);
+    }
+    await ensureParentDirectory(destinationPath);
+    const writer = runtime.createArchiveWriter(outputFormat, createFileWritable(destinationPath));
+    const entries = sourceIsDirectory
+        ? await collectDirectoryEntries(sourcePath, options)
+        : [{
+                sourcePath,
+                archivePath: path.basename(sourcePath).replace(/\\/g, '/')
+            }];
+    for (const entry of entries) {
+        const bytes = await fsPromises.readFile(entry.sourcePath);
+        await writer.add(entry.archivePath, bytes);
+    }
+    await writer.close();
+    return {
+        format: outputFormat,
+        source: sourcePath,
+        destination: destinationPath,
+        entryCount: entries.length,
+        wrappedDirectoryCodec
+    };
+};
+const collectDirectoryEntries = async (sourcePath, options) => {
+    var _a;
+    const includeBaseDirectory = options.includeBaseDirectory === true;
+    const followSymlinks = options.followSymlinks === true;
+    const sourceBaseName = path.basename(sourcePath);
+    const excludeMatcher = createExcludeMatcher(sourcePath, (_a = options.exclude) !== null && _a !== void 0 ? _a : []);
+    const visitedDirectories = new Set();
+    const toVisit = [sourcePath];
+    const files = [];
+    while (toVisit.length > 0) {
+        const nextDirectory = toVisit.pop();
+        if (!nextDirectory) {
+            continue;
+        }
+        if (followSymlinks) {
+            const real = await fsPromises.realpath(nextDirectory).catch(() => null);
+            if (!real || visitedDirectories.has(real)) {
+                continue;
+            }
+            visitedDirectories.add(real);
+        }
+        const directoryEntries = await fsPromises.readdir(nextDirectory, { withFileTypes: true });
+        directoryEntries.sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of directoryEntries) {
+            const sourceEntryPath = path.join(nextDirectory, entry.name);
+            const relativePath = path.relative(sourcePath, sourceEntryPath);
+            if (excludeMatcher.isExcluded(relativePath)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                toVisit.push(sourceEntryPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                files.push({
+                    sourcePath: sourceEntryPath,
+                    archivePath: toArchivePath(relativePath, includeBaseDirectory ? sourceBaseName : undefined)
+                });
+                continue;
+            }
+            if (!entry.isSymbolicLink() || !followSymlinks) {
+                continue;
+            }
+            const stats = await fsPromises.stat(sourceEntryPath).catch(() => null);
+            if (!stats) {
+                continue;
+            }
+            if (stats.isDirectory()) {
+                toVisit.push(sourceEntryPath);
+            }
+            else if (stats.isFile()) {
+                files.push({
+                    sourcePath: sourceEntryPath,
+                    archivePath: toArchivePath(relativePath, includeBaseDirectory ? sourceBaseName : undefined)
+                });
+            }
+        }
+    }
+    files.sort((left, right) => left.archivePath.localeCompare(right.archivePath));
+    return files;
+};
+const toArchiveOpenOptions = (options) => {
+    const archiveOptions = {};
+    if (options.format !== undefined) {
+        archiveOptions.format = options.format;
+    }
+    if (options.profile !== undefined) {
+        archiveOptions.profile = options.profile;
+    }
+    if (options.isStrict !== undefined) {
+        archiveOptions.isStrict = options.isStrict;
+    }
+    if (options.limits !== undefined) {
+        archiveOptions.limits = options.limits;
+    }
+    if (options.signal !== undefined) {
+        archiveOptions.signal = options.signal;
+    }
+    if (options.password !== undefined) {
+        archiveOptions.password = options.password;
+    }
+    if (options.filename !== undefined) {
+        archiveOptions.filename = options.filename;
+    }
+    return archiveOptions;
+};
+const toAuditOptions = (options) => {
+    const auditOptions = {};
+    if (options.profile !== undefined) {
+        auditOptions.profile = options.profile;
+    }
+    if (options.isStrict !== undefined) {
+        auditOptions.isStrict = options.isStrict;
+    }
+    if (options.limits !== undefined) {
+        auditOptions.limits = options.limits;
+    }
+    if (options.signal !== undefined) {
+        auditOptions.signal = options.signal;
+    }
+    return auditOptions;
+};
+const toNormalizeOptions = (options) => {
+    var _a;
+    const normalizeOptions = {
+        isDeterministic: (_a = options.deterministic) !== null && _a !== void 0 ? _a : true
+    };
+    if (options.limits !== undefined) {
+        normalizeOptions.limits = options.limits;
+    }
+    if (options.signal !== undefined) {
+        normalizeOptions.signal = options.signal;
+    }
+    return normalizeOptions;
+};
+const createExcludeMatcher = (sourcePath, excludes) => {
+    const excludedPaths = new Set();
+    const excludedNames = new Set();
+    const caseInsensitive = process.platform === 'win32';
+    for (const rawExclude of excludes) {
+        const normalizedExclude = normalizeExcludeInput(rawExclude, sourcePath);
+        if (!normalizedExclude) {
+            continue;
+        }
+        const hasSeparator = normalizedExclude.includes('/') || normalizedExclude.includes('\\') || normalizedExclude.includes(path.sep);
+        const normalizedValue = normalizeCase(normalizedExclude, caseInsensitive);
+        excludedPaths.add(normalizedValue);
+        if (!hasSeparator) {
+            excludedNames.add(normalizedValue);
+        }
+    }
+    return {
+        isExcluded(relativePath) {
+            const normalizedRelativePath = normalizeCase(path.normalize(relativePath), caseInsensitive);
+            if (excludedPaths.has(normalizedRelativePath)) {
+                return true;
+            }
+            const baseName = normalizeCase(path.basename(normalizedRelativePath), caseInsensitive);
+            return excludedNames.has(baseName);
+        }
+    };
+};
+const normalizeExcludeInput = (excludeRaw, sourcePath) => {
+    if (typeof excludeRaw !== 'string') {
+        return undefined;
+    }
+    const trimmed = excludeRaw.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    let normalized = path.normalize(trimmed.replace(/\\/g, path.sep));
+    if (normalized === '.' || normalized === path.sep) {
+        return undefined;
+    }
+    if (path.isAbsolute(normalized)) {
+        const relativeCandidate = path.relative(sourcePath, normalized);
+        const isInsideSource = relativeCandidate.length > 0
+            && !relativeCandidate.startsWith('..')
+            && !path.isAbsolute(relativeCandidate);
+        if (isInsideSource) {
+            normalized = path.normalize(relativeCandidate);
+        }
+    }
+    normalized = trimTrailingPathSeparators(normalized);
+    if (normalized.length === 0 || normalized === '.') {
+        return undefined;
+    }
+    return normalized;
+};
+const normalizeCase = (value, caseInsensitive) => {
+    return caseInsensitive ? value.toLowerCase() : value;
+};
+const trimTrailingPathSeparators = (value) => {
+    let end = value.length;
+    while (end > 0) {
+        const code = value.charCodeAt(end - 1);
+        if (code === 47 || code === 92) {
+            end -= 1;
+            continue;
+        }
+        break;
+    }
+    return value.slice(0, end);
+};
+const toArchivePath = (relativePath, baseDirectory) => {
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (baseDirectory) {
+        return path.posix.join(baseDirectory, normalized);
+    }
+    return normalized;
+};
+const normalizeArchiveEntryName = (entryName) => {
+    const normalizedSlashes = entryName.replace(/\\/g, '/');
+    if (normalizedSlashes.length === 0) {
+        throw new DirArchiverError('DIRARCHIVER_PATH_TRAVERSAL', 'Archive entry name is empty.');
+    }
+    if (normalizedSlashes.startsWith('/') || /^[a-zA-Z]:\//u.test(normalizedSlashes)) {
+        throw new DirArchiverError('DIRARCHIVER_PATH_TRAVERSAL', `Archive entry "${entryName}" is absolute and cannot be extracted safely.`);
+    }
+    const parts = normalizedSlashes.split('/').filter((part) => part.length > 0 && part !== '.');
+    if (parts.some((part) => part === '..')) {
+        throw new DirArchiverError('DIRARCHIVER_PATH_TRAVERSAL', `Archive entry "${entryName}" escapes extraction root.`);
+    }
+    return parts.join('/');
+};
+const resolveEntryDestination = (destinationRoot, entryName) => {
+    const safeRelative = normalizeArchiveEntryName(entryName);
+    const resolved = path.resolve(destinationRoot, safeRelative);
+    if (resolved !== destinationRoot && !resolved.startsWith(`${destinationRoot}${path.sep}`)) {
+        throw new DirArchiverError('DIRARCHIVER_PATH_TRAVERSAL', `Archive entry "${entryName}" resolves outside destination root.`);
+    }
+    return resolved;
+};
+const normalizeSymlinkTarget = (linkName) => {
+    const normalized = linkName.replace(/\\/g, '/');
+    if (normalized.startsWith('/') || /^[a-zA-Z]:\//u.test(normalized)) {
+        throw new DirArchiverError('DIRARCHIVER_PATH_TRAVERSAL', `Symlink target "${linkName}" is absolute and not allowed.`);
+    }
+    const parts = normalized.split('/').filter((part) => part.length > 0 && part !== '.');
+    if (parts.some((part) => part === '..')) {
+        throw new DirArchiverError('DIRARCHIVER_PATH_TRAVERSAL', `Symlink target "${linkName}" escapes extraction root.`);
+    }
+    return parts.join('/');
+};
+const readAllBytes = async (stream, maxEntryBytes, maxTotalBytes, currentTotalBytes = 0) => {
+    const reader = stream.getReader();
+    const chunks = [];
+    let entryTotal = 0;
+    try {
+        for (;;) {
+            const chunk = await reader.read();
+            if (chunk.done) {
+                break;
+            }
+            if (!(chunk.value instanceof Uint8Array)) {
+                continue;
+            }
+            entryTotal += chunk.value.length;
+            if (typeof maxEntryBytes === 'number' && entryTotal > maxEntryBytes) {
+                throw new DirArchiverError('DIRARCHIVER_RESOURCE_LIMIT', `Entry exceeds maxEntryBytes (${maxEntryBytes}).`, {
+                    context: {
+                        maxEntryBytes,
+                        actualEntryBytes: entryTotal
+                    }
+                });
+            }
+            const projectedTotal = currentTotalBytes + entryTotal;
+            if (typeof maxTotalBytes === 'number' && projectedTotal > maxTotalBytes) {
+                throw new DirArchiverError('DIRARCHIVER_RESOURCE_LIMIT', `Extraction exceeds maxTotalExtractedBytes (${maxTotalBytes}).`, {
+                    context: {
+                        maxTotalExtractedBytes: maxTotalBytes,
+                        projectedTotalBytes: projectedTotal
+                    }
+                });
+            }
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const output = new Uint8Array(entryTotal);
+    let offset = 0;
+    for (const chunk of chunks) {
+        output.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return output;
+};
+const ensureParentDirectory = async (targetPath) => {
+    await fsPromises.mkdir(path.dirname(targetPath), { recursive: true });
+};
+const createFileWritable = (targetPath) => {
+    const writable = createWriteStream(targetPath);
+    return Writable.toWeb(writable);
+};
+const inferFormatFromDestination = (destinationPath) => {
+    const lower = destinationPath.toLowerCase();
+    if (lower.endsWith('.tar.gz') || lower.endsWith('.tgz'))
+        return 'tar.gz';
+    if (lower.endsWith('.tar.bz2'))
+        return 'tar.bz2';
+    if (lower.endsWith('.tar.xz'))
+        return 'tar.xz';
+    if (lower.endsWith('.tar.zst'))
+        return 'tar.zst';
+    if (lower.endsWith('.tar.br'))
+        return 'tar.br';
+    if (lower.endsWith('.tar'))
+        return 'tar';
+    if (lower.endsWith('.zip'))
+        return 'zip';
+    if (lower.endsWith('.gz'))
+        return 'gz';
+    if (lower.endsWith('.bz2'))
+        return 'bz2';
+    if (lower.endsWith('.xz'))
+        return 'xz';
+    if (lower.endsWith('.zst'))
+        return 'zst';
+    if (lower.endsWith('.br'))
+        return 'br';
+    return undefined;
+};
+export const copyStreamToFile = async (source, destination) => {
+    await ensureParentDirectory(destination);
+    const nodeReadable = createReadStream(source);
+    const webReadable = Readable.toWeb(nodeReadable);
+    const bytes = await readAllBytes(webReadable);
+    await fsPromises.writeFile(destination, bytes);
+};
+export const pathExists = (value) => existsSync(value);
+export const fileSize = (value) => statSync(value).size;
+const disposeArchiveReader = async (reader) => {
+    const withAsyncDispose = reader;
+    const asyncDispose = withAsyncDispose[Symbol.asyncDispose];
+    if (typeof asyncDispose === 'function') {
+        await asyncDispose.call(withAsyncDispose);
+        return;
+    }
+    if (typeof withAsyncDispose.dispose === 'function') {
+        await withAsyncDispose.dispose();
+        return;
+    }
+    if (typeof withAsyncDispose.close === 'function') {
+        await withAsyncDispose.close();
+    }
+};

package/dist/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Stable dir-archiver error codes.
+ */
+export type DirArchiverErrorCode = 'DIRARCHIVER_INVALID_SOURCE' | 'DIRARCHIVER_INVALID_DESTINATION' | 'DIRARCHIVER_PATH_TRAVERSAL' | 'DIRARCHIVER_UNSUPPORTED_ENTRY' | 'DIRARCHIVER_RESOURCE_LIMIT' | 'DIRARCHIVER_RUNTIME_UNSUPPORTED' | 'DIRARCHIVER_NORMALIZE_UNSUPPORTED' | 'DIRARCHIVER_USAGE';
+/**
+ * Structured error contract for dir-archiver v3.
+ */
+export declare class DirArchiverError extends Error {
+    readonly code: DirArchiverErrorCode;
+    readonly hint: string | undefined;
+    readonly context: Record<string, unknown> | undefined;
+    constructor(code: DirArchiverErrorCode, message: string, options?: {
+        hint?: string | undefined;
+        context?: Record<string, unknown> | undefined;
+        cause?: unknown;
+    });
+    toJSON(): {
+        schemaVersion: '1';
+        name: 'DirArchiverError';
+        code: DirArchiverErrorCode;
+        message: string;
+        hint?: string;
+        context?: Record<string, unknown>;
+    };
+}

package/dist/errors.js

@@ -0,0 +1,25 @@
+/**
+ * Structured error contract for dir-archiver v3.
+ */
+export class DirArchiverError extends Error {
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = 'DirArchiverError';
+        this.code = code;
+        this.hint = options.hint;
+        this.context = options.context;
+        if (options.cause !== undefined) {
+            this.cause = options.cause;
+        }
+    }
+    toJSON() {
+        return {
+            schemaVersion: '1',
+            name: 'DirArchiverError',
+            code: this.code,
+            message: this.message,
+            ...(this.hint ? { hint: this.hint } : {}),
+            ...(this.context ? { context: this.context } : {})
+        };
+    }
+}

package/dist/index.d.ts

@@ -1,28 +1,19 @@
-declare class DirArchiver {
-    private excludedPaths;
-    private excludedNames;
-    private caseInsensitiveExcludes;
-    private directoryPath;
-    private zipPath;
-    private includeBaseDirectory;
-    private followSymlinks;
-    private baseDirectory;
-    private visitedDirectories;
-    /**
-     * The constructor.
-     * @param directoryPath - the path of the folder to archive.
-     * @param zipPath - The path of the zip file to create.
-     * @param includeBaseDirectory - Includes a base directory at the root of the archive. For example, if the root folder of your project is named "your-project", setting includeBaseDirectory to true will create an archive that includes this base directory. If this option is set to false the archive created will unzip its content to the current directory.
-     * @param excludes - The name of the files and foldes to exclude.
-     */
-    constructor(directoryPath: string, zipPath: string, includeBaseDirectory?: boolean, excludes?: string[], followSymlinks?: boolean);
-    /**
-     * Recursively traverse the directory tree and append the files to the archive.
-     * @param directoryPath - The path of the directory being looped through.
-     */
-    private traverseDirectoryTree;
-    private prettyBytes;
-    private normalizeExcludeValue;
-    createZip(): Promise<string>;
-}
-export = DirArchiver;
+/**
+ * dir-archiver v3 API surface.
+ *
+ * v3 is a bytefold-backed orchestration layer that supports Node.js, Deno, and Bun.
+ */
+import { audit, detect, extract, list, normalize, open, write } from './core.js';
+export { audit, detect, extract, list, normalize, open, write };
+export { DirArchiverError } from './errors.js';
+export type { ArchiveFormat, ArchiveLimits, ArchiveProfile, CliUsageError, DetectResult, DirArchiverInput, ExtractOptions, ExtractResult, ListEntry, ListResult, NormalizeOptions, NormalizeResult, OpenOptions, SupportedCommandMap, WriteOptions, WriteResult } from './types.js';
+declare const api: {
+    open: (input: import("./types.js").DirArchiverInput, options?: import("./types.js").OpenOptions) => Promise<import("@ismail-elkorchi/bytefold").ArchiveReader>;
+    detect: (input: import("./types.js").DirArchiverInput, options?: import("./types.js").OpenOptions) => Promise<import("./types.js").DetectResult>;
+    list: (input: import("./types.js").DirArchiverInput, options?: import("./types.js").OpenOptions) => Promise<import("./types.js").ListResult>;
+    audit: (input: import("./types.js").DirArchiverInput, options?: import("./types.js").OpenOptions) => Promise<import("@ismail-elkorchi/bytefold").ArchiveAuditReport>;
+    normalize: (input: import("./types.js").DirArchiverInput, destination: string, options?: import("./types.js").NormalizeOptions) => Promise<import("./types.js").NormalizeResult>;
+    extract: (input: import("./types.js").DirArchiverInput, destination: string, options?: import("./types.js").ExtractOptions) => Promise<import("./types.js").ExtractResult>;
+    write: (source: string, destination: string, options?: import("./types.js").WriteOptions) => Promise<import("./types.js").WriteResult>;
+};
+export default api;