@clearmist-labs/comic-archive-handler 1.1.1 → 1.3.0

package/README.md

@@ -11,7 +11,7 @@ A toolkit for detecting, converting, and manipulating comic book archives (CBAS/
 - **Re-encode** page images to different formats
 - **Hash** archives perceptually and by content
 - **Rename** pages sequentially
-- **Strip** non-essential files from archives
+- **Strip** non-essential files from archives, or **remove** a single named entry
 - **Extract** archives to a plain directory of files
 - **Benchmark** archive/image format combinations for creation speed, random read speed, and size
 

package/dist/index.d.mts

@@ -61,6 +61,7 @@ export interface RenameOptions extends ArchiveWriteOptions {
 export interface StripOptions extends ArchiveWriteOptions {
   extraKeepExtensions?: string[];
 }
+export type RemoveEntryOptions = ArchiveWriteOptions;
 export interface ComicCredit {
   name: string;
   role: string;
@@ -480,12 +481,13 @@ export declare function sha256Archive(input: ArchiveInput): Promise<string>;
  * ComicInfo.xml/MetronInfo.xml) untouched.
  *
  * This requires two passes over the archive: `listEntries` is called once to
- * collect image paths (metadata only — no content is read, so no
+ * collect image paths (metadata only, no content is read, so no
  * decompression work is wasted) to compute the sort-order rename map, then
- * called again to stream entries out under their new names. Streaming
- * adapters (zip in particular) can't be "rewound" mid-read, so the second
- * pass re-invokes `listEntries` from the start rather than reusing entry
- * objects collected in the first pass.
+ * called again to stream entries out under their new names. `listEntries` is
+ * re-invoked from the start for the second pass rather than reusing entry
+ * objects collected in the first, since the sequential/CLI-driven adapters
+ * (rar, 7z, ace, tar) can't be "rewound" mid-read even though zip and asar
+ * could serve both passes from the entries collected the first time round.
  */
 export declare function renameArchiveImagesSequentially(input: ArchiveInput, options?: RenameOptions): Promise<Buffer | void>;
 //#endregion
@@ -498,6 +500,29 @@ export declare function listArchiveFiles(input: ArchiveInput): Promise<string[]>
 //#region src/readArchiveEntry.d.ts
 export declare function readArchiveEntry(input: ArchiveInput, entryPath: string): Promise<Buffer>;
 //#endregion
+//#region src/readArchiveEntries.d.ts
+export interface ReadArchiveEntriesResult {
+  path: string;
+  size?: number;
+  buffer: Buffer;
+  sha256: string;
+}
+/**
+ * Reads every entry's bytes and SHA256 in a single pass over the archive.
+ * Calling `readArchiveEntry`/`sha256ArchiveEntry` once per entry instead
+ * means re-running `listEntries` and re-locating the target entry on every
+ * call — cheap for zip (backed by real central-directory random access) and
+ * tar/asar, but for the sequential/CLI-driven formats (rar, 7z, ace) each
+ * call re-reads the archive from the start, so reading every entry that way
+ * costs O(n^2). This also does half the I/O of calling both
+ * `sha256ArchiveEntry` and `readArchiveEntry` per entry, since it computes
+ * the hash and buffer from the same read instead of two.
+ */
+export declare function readArchiveEntries(input: ArchiveInput): AsyncGenerator<ReadArchiveEntriesResult>;
+//#endregion
+//#region src/removeArchiveEntry.d.ts
+export declare function removeArchiveEntry(input: ArchiveInput, entryPath: string, options?: RemoveEntryOptions): Promise<Buffer | void>;
+//#endregion
 //#region src/benchmark/benchmarkArchive.d.ts
 /**
  * Extracts a comic archive, validates it contains image files, then
@@ -537,6 +562,8 @@ declare const comicArchiveHandler: {
   stripNonEssentialFiles: typeof stripNonEssentialFiles;
   listArchiveFiles: typeof listArchiveFiles;
   readArchiveEntry: typeof readArchiveEntry;
+  readArchiveEntries: typeof readArchiveEntries;
+  removeArchiveEntry: typeof removeArchiveEntry;
   benchmarkArchive: typeof benchmarkArchive;
   renderBenchmarkReportMarkdown: typeof renderBenchmarkReportMarkdown;
   WRITABLE_ARCHIVE_TYPES: readonly WritableArchiveType[];

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/benchmark/types.ts","../src/errors.ts","../src/detect.ts","../src/convertArchive.ts","../src/extractArchive.ts","../src/metadata/comicInfo.ts","../src/metadata/metronInfo.ts","../src/metadata/validate.ts","../src/metadata/schema.ts","../src/metadata/index.ts","../src/images/convert.ts","../src/images/phash.ts","../src/images/isImage.ts","../src/hashing/sha256.ts","../src/rename.ts","../src/strip.ts","../src/listFiles.ts","../src/readArchiveEntry.ts","../src/benchmark/benchmarkArchive.ts","../src/benchmark/report.ts","../src/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/benchmark/types.ts","../src/errors.ts","../src/detect.ts","../src/convertArchive.ts","../src/extractArchive.ts","../src/metadata/comicInfo.ts","../src/metadata/metronInfo.ts","../src/metadata/validate.ts","../src/metadata/schema.ts","../src/metadata/index.ts","../src/images/convert.ts","../src/images/phash.ts","../src/images/isImage.ts","../src/hashing/sha256.ts","../src/rename.ts","../src/strip.ts","../src/listFiles.ts","../src/readArchiveEntry.ts","../src/readArchiveEntries.ts","../src/removeArchiveEntry.ts","../src/benchmark/benchmarkArchive.ts","../src/benchmark/report.ts","../src/index.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -4,7 +4,7 @@ import * as fs from "node:fs";
 import { existsSync, readFileSync } from "node:fs";
 import * as fsp from "node:fs/promises";
 import { PassThrough, Readable } from "node:stream";
-import { Unzip, UnzipInflate, Zip, ZipDeflate } from "fflate";
+import { Zip, ZipDeflate, inflateSync } from "fflate";
 import * as tarStream from "tar-stream";
 import { createExtractorFromData } from "node-unrar-js";
 import * as path from "node:path";
@@ -199,86 +199,163 @@ async function isAce(input) {
 	return await detectArchiveType(input) === "ace";
 }
 //#endregion
-//#region src/internal/streamUtils.ts
-async function streamToBuffer(stream) {
-	const chunks = [];
-	for await (const chunk of stream) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-	return Buffer.concat(chunks);
+//#region src/internal/zipCentralDirectory.ts
+const EOCD_SIGNATURE = 101010256;
+const ZIP64_EOCD_LOCATOR_SIGNATURE = 117853008;
+const ZIP64_EOCD_SIGNATURE = 101075792;
+const CENTRAL_DIRECTORY_SIGNATURE = 33639248;
+const LOCAL_FILE_HEADER_SIGNATURE = 67324752;
+const ZIP64_EXTRA_FIELD_ID = 1;
+const EOCD_FIXED_SIZE = 22;
+const EOCD_MAX_COMMENT_SIZE = 65535;
+const ZIP64_EOCD_LOCATOR_SIZE = 20;
+const UINT32_MAX = 4294967295;
+const UINT16_MAX = 65535;
+/**
+* The end-of-central-directory record sits at the end of the file, after an
+* optional variable-length comment, so it's found by scanning backward from
+* the end for its signature rather than reading forward from the start.
+*/
+async function findEndOfCentralDirectory(input) {
+	const size = await inputSize(input);
+	const searchStart = Math.max(0, size - EOCD_FIXED_SIZE - EOCD_MAX_COMMENT_SIZE);
+	const tail = await readInputRange(input, searchStart, size);
+	for (let i = tail.length - EOCD_FIXED_SIZE; i >= 0; i--) if (tail.readUInt32LE(i) === EOCD_SIGNATURE) return {
+		record: tail.subarray(i),
+		offset: searchStart + i
+	};
+	throw new ArchiveFormatError("Not a valid zip archive: no end-of-central-directory record found.");
 }
-/** Bridges a callback-driven push source into an async iterable, in arrival order. */
-var AsyncQueue = class {
-	items = [];
-	waiter = null;
-	done = false;
-	error = null;
-	push(item) {
-		this.items.push(item);
-		this.waiter?.();
-	}
-	finish() {
-		this.done = true;
-		this.waiter?.();
-	}
-	fail(err) {
-		this.error = err;
-		this.done = true;
-		this.waiter?.();
-	}
-	async *[Symbol.asyncIterator]() {
-		for (;;) {
-			if (this.items.length) {
-				yield this.items.shift();
-				continue;
+/**
+* Zip64 stores the real (64-bit) totals in its own record, pointed to by a
+* fixed-size locator that sits immediately before the regular
+* end-of-central-directory record.
+*/
+async function readZip64EndOfCentralDirectory(input, eocdOffset) {
+	const locatorOffset = eocdOffset - ZIP64_EOCD_LOCATOR_SIZE;
+	if (locatorOffset < 0) throw new ArchiveFormatError("Not a valid zip64 archive: missing end-of-central-directory locator.");
+	const locator = await readInputRange(input, locatorOffset, locatorOffset + ZIP64_EOCD_LOCATOR_SIZE);
+	if (locator.length < ZIP64_EOCD_LOCATOR_SIZE || locator.readUInt32LE(0) !== ZIP64_EOCD_LOCATOR_SIGNATURE) throw new ArchiveFormatError("Not a valid zip64 archive: missing end-of-central-directory locator.");
+	const zip64EocdOffset = Number(locator.readBigUInt64LE(8));
+	const record = await readInputRange(input, zip64EocdOffset, zip64EocdOffset + 56);
+	if (record.length < 56 || record.readUInt32LE(0) !== ZIP64_EOCD_SIGNATURE) throw new ArchiveFormatError("Not a valid zip64 archive: malformed end-of-central-directory record.");
+	return {
+		totalEntries: Number(record.readBigUInt64LE(32)),
+		centralDirectorySize: Number(record.readBigUInt64LE(40)),
+		centralDirectoryOffset: Number(record.readBigUInt64LE(48))
+	};
+}
+/** Reads the zip64 extra field's 8-byte values for whichever fixed-header fields overflowed 32 bits, in the fixed order the spec requires: uncompressed size, compressed size, local header offset. */
+function readZip64ExtraField(extra, overflowed) {
+	let pos = 0;
+	while (pos + 4 <= extra.length) {
+		const fieldId = extra.readUInt16LE(pos);
+		const fieldSize = extra.readUInt16LE(pos + 2);
+		if (fieldId === ZIP64_EXTRA_FIELD_ID) {
+			let valuePos = pos + 4;
+			const result = {};
+			if (overflowed.uncompressedSize && valuePos + 8 <= extra.length) {
+				result.uncompressedSize = Number(extra.readBigUInt64LE(valuePos));
+				valuePos += 8;
 			}
-			if (this.error) throw this.error;
-			if (this.done) return;
-			await new Promise((resolve) => {
-				this.waiter = resolve;
-			});
-			this.waiter = null;
+			if (overflowed.compressedSize && valuePos + 8 <= extra.length) {
+				result.compressedSize = Number(extra.readBigUInt64LE(valuePos));
+				valuePos += 8;
+			}
+			if (overflowed.localHeaderOffset && valuePos + 8 <= extra.length) {
+				result.localHeaderOffset = Number(extra.readBigUInt64LE(valuePos));
+				valuePos += 8;
+			}
+			return result;
 		}
+		pos += 4 + fieldSize;
 	}
-};
-//#endregion
-//#region src/archive/zip.ts
-function toEntry(file) {
-	return {
-		path: file.name,
-		size: file.originalSize,
-		openReadStream() {
-			const pass = new PassThrough();
-			file.ondata = (err, data, final) => {
-				if (err) {
-					pass.destroy(err);
-					return;
-				}
-				if (data.length) pass.write(Buffer.from(data));
-				if (final) pass.end();
-			};
-			file.start();
-			return pass;
+	throw new ArchiveFormatError("Not a valid zip64 archive: an oversized entry is missing its zip64 extra field.");
+}
+/**
+* Parses a zip's central directory — the entry index at the end of the
+* file — into per-entry metadata (name, sizes, compression method, and the
+* offset of its local file header). Reading this index costs a couple of
+* small range reads regardless of archive size; it never reads or
+* decompresses entry data itself, which is why entries can then be read in
+* any order at O(1) cost each rather than needing a forward scan through
+* every entry that precedes the one wanted.
+*/
+async function parseZipCentralDirectory(input) {
+	const { record: eocd, offset: eocdOffset } = await findEndOfCentralDirectory(input);
+	let totalEntries = eocd.readUInt16LE(10);
+	let centralDirectorySize = eocd.readUInt32LE(12);
+	let centralDirectoryOffset = eocd.readUInt32LE(16);
+	if (totalEntries === UINT16_MAX || centralDirectorySize === UINT32_MAX || centralDirectoryOffset === UINT32_MAX) ({totalEntries, centralDirectorySize, centralDirectoryOffset} = await readZip64EndOfCentralDirectory(input, eocdOffset));
+	const centralDirectory = await readInputRange(input, centralDirectoryOffset, centralDirectoryOffset + centralDirectorySize);
+	const entries = [];
+	let pos = 0;
+	for (let i = 0; i < totalEntries; i++) {
+		if (pos + 46 > centralDirectory.length || centralDirectory.readUInt32LE(pos) !== CENTRAL_DIRECTORY_SIGNATURE) throw new ArchiveFormatError("Not a valid zip archive: malformed central directory entry.");
+		const compressionMethod = centralDirectory.readUInt16LE(pos + 10);
+		let compressedSize = centralDirectory.readUInt32LE(pos + 20);
+		let uncompressedSize = centralDirectory.readUInt32LE(pos + 24);
+		const nameLength = centralDirectory.readUInt16LE(pos + 28);
+		const extraLength = centralDirectory.readUInt16LE(pos + 30);
+		const commentLength = centralDirectory.readUInt16LE(pos + 32);
+		let localHeaderOffset = centralDirectory.readUInt32LE(pos + 42);
+		const name = centralDirectory.toString("utf8", pos + 46, pos + 46 + nameLength);
+		const overflowed = {
+			uncompressedSize: uncompressedSize === UINT32_MAX,
+			compressedSize: compressedSize === UINT32_MAX,
+			localHeaderOffset: localHeaderOffset === UINT32_MAX
+		};
+		if (overflowed.uncompressedSize || overflowed.compressedSize || overflowed.localHeaderOffset) {
+			const zip64Values = readZip64ExtraField(centralDirectory.subarray(pos + 46 + nameLength, pos + 46 + nameLength + extraLength), overflowed);
+			uncompressedSize = zip64Values.uncompressedSize ?? uncompressedSize;
+			compressedSize = zip64Values.compressedSize ?? compressedSize;
+			localHeaderOffset = zip64Values.localHeaderOffset ?? localHeaderOffset;
 		}
-	};
+		if (!name.endsWith("/")) entries.push({
+			path: name,
+			compressedSize,
+			uncompressedSize,
+			compressionMethod,
+			localHeaderOffset
+		});
+		pos += 46 + nameLength + extraLength + commentLength;
+	}
+	return entries;
+}
+/**
+* Reads and decompresses one entry's data, using its central directory
+* metadata to locate the bytes directly — no scan through other entries.
+* The local file header still has to be read first because its name/extra
+* field lengths (which can differ from the central directory's) are what
+* determine where the entry's actual data starts.
+*/
+async function readZipEntryData(input, entry) {
+	const localHeader = await readInputRange(input, entry.localHeaderOffset, entry.localHeaderOffset + 30);
+	if (localHeader.length < 30 || localHeader.readUInt32LE(0) !== LOCAL_FILE_HEADER_SIGNATURE) throw new ArchiveFormatError(`Not a valid zip archive: malformed local file header for "${entry.path}".`);
+	const nameLength = localHeader.readUInt16LE(26);
+	const extraLength = localHeader.readUInt16LE(28);
+	const dataStart = entry.localHeaderOffset + 30 + nameLength + extraLength;
+	const compressed = await readInputRange(input, dataStart, dataStart + entry.compressedSize);
+	if (entry.compressionMethod === 0) return compressed;
+	if (entry.compressionMethod === 8) return Buffer.from(inflateSync(compressed));
+	throw new ArchiveFormatError(`Unsupported zip compression method (${entry.compressionMethod}) for "${entry.path}".`);
 }
+//#endregion
+//#region src/archive/zip.ts
 const zipAdapter = {
 	type: "zip",
 	canWrite: true,
 	async *listEntries(input) {
-		const source = openInputReadStream(input);
-		const queue = new AsyncQueue();
-		const unzip = new Unzip();
-		unzip.register(UnzipInflate);
-		unzip.onfile = (file) => {
-			if (file.name.endsWith("/")) return;
-			queue.push(toEntry(file));
+		const entries = await parseZipCentralDirectory(input);
+		for (const entry of entries) yield {
+			path: entry.path,
+			size: entry.uncompressedSize,
+			openReadStream() {
+				return Readable.from((async function* () {
+					yield await readZipEntryData(input, entry);
+				})());
+			}
 		};
-		source.on("data", (chunk) => unzip.push(new Uint8Array(chunk), false));
-		source.on("end", () => {
-			unzip.push(/* @__PURE__ */ new Uint8Array(0), true);
-			queue.finish();
-		});
-		source.on("error", (err) => queue.fail(err));
-		yield* queue;
 	},
 	async write(entries, destination) {
 		await new Promise((resolve, reject) => {
@@ -307,6 +384,13 @@ const zipAdapter = {
 	}
 };
 //#endregion
+//#region src/internal/streamUtils.ts
+async function streamToBuffer(stream) {
+	const chunks = [];
+	for await (const chunk of stream) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	return Buffer.concat(chunks);
+}
+//#endregion
 //#region src/archive/tar.ts
 /**
 * The tar-stream v3 package is built on `streamx`, not Node's native streams;
@@ -1844,12 +1928,13 @@ function naturalCompare(a, b) {
 * ComicInfo.xml/MetronInfo.xml) untouched.
 *
 * This requires two passes over the archive: `listEntries` is called once to
-* collect image paths (metadata only — no content is read, so no
+* collect image paths (metadata only, no content is read, so no
 * decompression work is wasted) to compute the sort-order rename map, then
-* called again to stream entries out under their new names. Streaming
-* adapters (zip in particular) can't be "rewound" mid-read, so the second
-* pass re-invokes `listEntries` from the start rather than reusing entry
-* objects collected in the first pass.
+* called again to stream entries out under their new names. `listEntries` is
+* re-invoked from the start for the second pass rather than reusing entry
+* objects collected in the first, since the sequential/CLI-driven adapters
+* (rar, 7z, ace, tar) can't be "rewound" mid-read even though zip and asar
+* could serve both passes from the entries collected the first time round.
 */
 async function renameArchiveImagesSequentially(input, options = {}) {
 	const adapter = getAdapter(await detectArchiveType(input));
@@ -1909,6 +1994,59 @@ async function readArchiveEntry(input, entryPath) {
 	throw new MetadataNotFoundError(`No entry named "${entryPath}" was found in the archive.`);
 }
 //#endregion
+//#region src/readArchiveEntries.ts
+/**
+* Reads every entry's bytes and SHA256 in a single pass over the archive.
+* Calling `readArchiveEntry`/`sha256ArchiveEntry` once per entry instead
+* means re-running `listEntries` and re-locating the target entry on every
+* call — cheap for zip (backed by real central-directory random access) and
+* tar/asar, but for the sequential/CLI-driven formats (rar, 7z, ace) each
+* call re-reads the archive from the start, so reading every entry that way
+* costs O(n^2). This also does half the I/O of calling both
+* `sha256ArchiveEntry` and `readArchiveEntry` per entry, since it computes
+* the hash and buffer from the same read instead of two.
+*/
+async function* readArchiveEntries(input) {
+	const adapter = getAdapter(await detectArchiveType(input));
+	for await (const entry of adapter.listEntries(input)) {
+		const hash = createHash("sha256");
+		const chunks = [];
+		for await (const chunk of entry.openReadStream()) {
+			const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+			chunks.push(buffer);
+			hash.update(buffer);
+		}
+		yield {
+			path: entry.path,
+			size: entry.size,
+			buffer: Buffer.concat(chunks),
+			sha256: hash.digest("hex")
+		};
+	}
+}
+//#endregion
+//#region src/removeArchiveEntry.ts
+async function removeArchiveEntry(input, entryPath, options = {}) {
+	const adapter = getAdapter(await detectArchiveType(input));
+	let found = false;
+	for await (const entry of adapter.listEntries(input, { tempDir: options.tempDir })) if (entry.path === entryPath) {
+		found = true;
+		break;
+	}
+	if (!found) throw new MetadataNotFoundError(`No entry named "${entryPath}" was found in the archive.`);
+	async function* output() {
+		for await (const entry of adapter.listEntries(input, { tempDir: options.tempDir })) {
+			if (entry.path === entryPath) continue;
+			yield {
+				path: entry.path,
+				size: entry.size,
+				content: entry.openReadStream()
+			};
+		}
+	}
+	return withOutput(options.output, (destination) => adapter.write(output(), destination, { tempDir: options.tempDir }));
+}
+//#endregion
 //#region src/benchmark/timing.ts
 /** Runs `run` `iterations` times and returns the average duration in milliseconds. */
 async function averageDuration(iterations, run) {
@@ -2153,6 +2291,8 @@ const comicArchiveHandler = {
 	stripNonEssentialFiles,
 	listArchiveFiles,
 	readArchiveEntry,
+	readArchiveEntries,
+	removeArchiveEntry,
 	benchmarkArchive,
 	renderBenchmarkReportMarkdown,
 	WRITABLE_ARCHIVE_TYPES,
@@ -2160,6 +2300,6 @@ const comicArchiveHandler = {
 	ARCHIVE_TYPE_EXTENSIONS
 };
 //#endregion
-export { ARCHIVE_TYPE_EXTENSIONS, ArchiveFormatError, BENCHMARK_IMAGE_FORMATS, COMIC_INFO_AGE_RATING_VALUES, COMIC_INFO_CREDIT_ROLES, COMIC_INFO_MANGA_VALUES, COMIC_INFO_PAGE_TYPE_VALUES, COMIC_INFO_YES_NO_VALUES, FilesystemAccessError, IMAGE_EXTENSIONS, METRON_AGE_RATING_VALUES, METRON_FORMAT_VALUES, METRON_INFORMATION_SOURCE_VALUES, METRON_ROLE_VALUES, MetadataNotFoundError, NoImagesFoundError, SevenZipUnavailableError, UnsupportedOperationError, WRITABLE_ARCHIVE_TYPES, addMetadataToArchive, benchmarkArchive, comicInfoXmlToMetadata, computeArchiveImagePHash, computeImagePHash, convertArchive, convertArchiveImages, convertImageBuffer, comicArchiveHandler as default, detectArchiveType, extractArchive, getExtension, hammingDistance, hasComicMetadata, is7z, isAce, isAsar, isImagePath, isRar, isTar, isZip, joinCommaList, joinResourceNames, listArchiveFiles, metadataToComicInfoXml, metadataToMetronInfoXml, metadataToXml, metronInfoXmlToMetadata, phashToHex, readArchiveEntry, readArchiveMetadata, renameArchiveImagesSequentially, renderBenchmarkReportMarkdown, resourceId, resourceName, sha256Archive, sha256ArchiveEntry, splitCommaList, stripNonEssentialFiles, validateMetadataXml, xmlToMetadata };
+export { ARCHIVE_TYPE_EXTENSIONS, ArchiveFormatError, BENCHMARK_IMAGE_FORMATS, COMIC_INFO_AGE_RATING_VALUES, COMIC_INFO_CREDIT_ROLES, COMIC_INFO_MANGA_VALUES, COMIC_INFO_PAGE_TYPE_VALUES, COMIC_INFO_YES_NO_VALUES, FilesystemAccessError, IMAGE_EXTENSIONS, METRON_AGE_RATING_VALUES, METRON_FORMAT_VALUES, METRON_INFORMATION_SOURCE_VALUES, METRON_ROLE_VALUES, MetadataNotFoundError, NoImagesFoundError, SevenZipUnavailableError, UnsupportedOperationError, WRITABLE_ARCHIVE_TYPES, addMetadataToArchive, benchmarkArchive, comicInfoXmlToMetadata, computeArchiveImagePHash, computeImagePHash, convertArchive, convertArchiveImages, convertImageBuffer, comicArchiveHandler as default, detectArchiveType, extractArchive, getExtension, hammingDistance, hasComicMetadata, is7z, isAce, isAsar, isImagePath, isRar, isTar, isZip, joinCommaList, joinResourceNames, listArchiveFiles, metadataToComicInfoXml, metadataToMetronInfoXml, metadataToXml, metronInfoXmlToMetadata, phashToHex, readArchiveEntries, readArchiveEntry, readArchiveMetadata, removeArchiveEntry, renameArchiveImagesSequentially, renderBenchmarkReportMarkdown, resourceId, resourceName, sha256Archive, sha256ArchiveEntry, splitCommaList, stripNonEssentialFiles, validateMetadataXml, xmlToMetadata };
 
 //# sourceMappingURL=index.mjs.map