epubcheck-standalone-cli 0.0.0-oidc-bootstrap → 5.3.0-build2

package/LICENSE

@@ -0,0 +1,37 @@
+BSD 3-Clause License
+
+This package (epubcheck-standalone-cli) is a command-line interface that mirrors the
+official epubcheck (w3c/epubcheck) CLI, implemented on top of the
+epubcheck-standalone package (which bundles and is derived from epubcheck).
+epubcheck is distributed under the BSD 3-Clause License; this CLI is
+released under the same license.
+
+Copyright © 2007 Adobe Systems Incorporated
+Copyright © 2008 IDPF
+Copyright © 2017 W3C (MIT, ERCIM, Keio, Beihang)
+Copyright © 2026 John L. Armstrong IV
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,112 @@
+# epubcheck-standalone-cli
+
+[![npm version](https://img.shields.io/npm/v/epubcheck-standalone-cli)](https://www.npmjs.com/package/epubcheck-standalone-cli) [![npm downloads](https://img.shields.io/npm/dm/epubcheck-standalone-cli)](https://www.npmjs.com/package/epubcheck-standalone-cli)
+
+The official EPUBCheck command line, with no Java to install. It mirrors EPUBCheck's own CLI: the same flags, console text, JSON, XML, and XMP report files, and exit codes. Under the hood it runs the [epubcheck-standalone](https://github.com/jlarmstrongiv/epubcheck-standalone/blob/main/packages/epubcheck-standalone/README.md) engine, EPUBCheck compiled to plain JavaScript with TeaVM, so output matches the Java tool byte for byte.
+
+- Validate an EPUB from your terminal with one command
+- No Java, no install: run it straight from `npx`
+- Same flags and same output as the official epubcheck CLI
+- Writes the same JSON, XML, and XMP report files
+- Your ebook never leaves your machine
+
+## Quickstart
+
+```sh
+npx epubcheck-standalone-cli book.epub
+```
+
+That prints the same report the official EPUBCheck prints:
+
+```
+Validating using EPUB version 3.3 rules.
+No errors or warnings detected.
+Messages: 0 fatals / 0 errors / 0 warnings / 0 infos
+
+EPUBCheck completed
+```
+
+Install it in a project and call it by its bin name `epubcheck-standalone-cli`. It needs Node.js LTS or newer.
+
+Validate a remote book by URL:
+
+```sh
+npx epubcheck-standalone-cli https://example.com/book.epub
+```
+
+The URL itself is the input, exactly like the official tool given a URL, so message locations reference the URL.
+
+## Flags
+
+Same short and long forms as the official EPUBCheck CLI.
+
+| Flag | What it does |
+| --- | --- |
+| `-j`, `--json <file>` | Write a JSON report to `<file>`. Use `-` for the console. |
+| `-o`, `--out <file>` | Write an XML report to `<file>`. Use `-` for the console. |
+| `-x`, `--xmp <file>` | Write an XMP report to `<file>`. Use `-` for the console. |
+| `-q`, `--quiet` | Silence normal stdout. Message lines, the summary, and any requested report still print. |
+| `-f`, `--fatal` | Show fatal messages only. |
+| `-e`, `--error` | Show error and fatal messages. |
+| `-w`, `--warn` | Show warning, error, and fatal messages. |
+| `-i`, `--info` | Show messages down to info level (the default). |
+| `-u`, `--usage` | Show usage-level messages too, the most detailed level. |
+| `-m`, `--mode <type>` | Validate a single file of the given type: `xhtml`, `opf`, `svg`, `mo`, `nav`. Pair with `-v` to set the EPUB version. |
+| `-p`, `--profile <name>` | Validate against a profile: `default`, `dict`, `edupub`, `idx`, `preview`. |
+| `-s`, `--save` | With `--mode exp`, keep the packaged `.epub` the check builds, written next to the input directory. A check that finds errors deletes it again and says so, like the official tool. |
+| `--locale <tag>` | Show messages in the given language (see below). |
+| `--failonwarnings` | Exit `1` on warnings, not just errors. |
+| `-l`, `--listChecks [<file>]` | Write message ids and severities to `<file>` or the console. Does not validate a book. |
+| `-c`, `--customMessages <file>` | Override message severities from a tab-separated file, to promote, demote, suppress, or reword messages. Pass `none` to turn overrides off. |
+| `--version` | Print the EPUBCheck version, in the `EPUBCheck v<version>` format. |
+| `-h`, `-?`, `--help` | Print the help text. |
+
+Only one report format can be requested per run. Asking for two is an error, the same as the official tool.
+
+`-v <2.0|3.0>` is accepted so existing scripts keep working, but it does nothing for an `.epub` file: EPUBCheck reads the version from the book itself and the official tool ignores it too. It is separate from `--version`.
+
+The saved `.epub` from `--save` matches the official tool's structurally: the same files in the same order, the same checksums, sizes, and timestamps, and `mimetype` stored first. The compressed bytes inside differ, because Node.js and Java ship different compressors. A directory whose packaged form passes 4 GB is written as a valid ZIP64 `.epub`, the same archive the official tool produces.
+
+## Languages
+
+`--locale` takes any tag from this list. Untranslated message text falls back to English, exactly as in the official tool.
+
+| Tag | Language |
+| --- | --- |
+| `da` | Danish |
+| `de` | German |
+| `en` | English (the default) |
+| `es` | Spanish |
+| `fr` | French |
+| `it` | Italian |
+| `ja` | Japanese |
+| `ko-KR` | Korean |
+| `nl` | Dutch |
+| `pt-BR` | Portuguese (Brazil) |
+| `zh-TW` | Chinese (Traditional) |
+
+A region added to one of these languages works too and behaves exactly like the official tool: it resolves to the language above by dropping the region. So `en-US` and `en-GB` show English, `fr-FR` shows French, `de-DE` shows German. Case and separator do not matter (`fr_FR`, `FR-fr`, and `fr-FR` are the same tag).
+
+These tags are refused (exit `2`): a bare `ko`, `pt`, or `zh` (those languages ship only with a region), and any language not in the list, such as `pl` or `ru`. The official tool falls back to English for those, but that fallback depends on the host machine's default language, so its result is not guaranteed to be the same on every machine. This tool refuses those tags rather than risk output that differs from the official tool. The `--listChecks` list is the one exception: like the official tool it never refuses a locale there, and an unsupported tag simply falls back to English.
+
+## Exit codes
+
+| Code | Meaning |
+| --- | --- |
+| `0` | Valid. No errors, no fatals. Also `0` when the only messages are warnings, unless you passed `--failonwarnings`. |
+| `1` | Errors or fatals found. Also `1` for a bad argument, a missing file, or a validation failure. |
+| `2` | You passed a valid EPUBCheck flag this engine cannot support. The tool stops with a clear message rather than print output that would differ from the official tool. |
+
+Codes `0` and `1` match the official EPUBCheck. Code `2` is specific to this tool, and the only flag that triggers it is a `--locale` tag outside the list above (see Languages). Everything else works: single-file `--mode` checks, expanded directories (`--mode exp`), all profiles, every shipped language, custom message overrides, and URL inputs. Validating a plain `.epub` needs none of these flags.
+
+## Relation to the library
+
+This tool is a thin command-line front end over the [epubcheck-standalone](https://github.com/jlarmstrongiv/epubcheck-standalone/blob/main/packages/epubcheck-standalone/README.md) library. The library is the engine; this package reproduces EPUBCheck's argument handling, console text, and exit codes on top of it. To validate EPUBs from your own code, use the library directly.
+
+## Versioning
+
+The version is the upstream EPUBCheck release baked into the engine, then a build number for this packaging. Same scheme as the library, explained in its [versioning section](https://github.com/jlarmstrongiv/epubcheck-standalone/blob/main/packages/epubcheck-standalone/README.md#versioning).
+
+## License
+
+BSD-3-Clause, the same license as EPUBCheck.

package/dist/archive.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Thresholds at which ZIP64 kicks in. They default to the real 32-bit/16-bit
+ * limits (so production output is unchanged), but are overridable so the ZIP64
+ * code path can be exercised on tiny inputs in tests. `size` governs the local
+ * size fields, the central size/offset fields, and the central-directory
+ * size/offset in the EOCD; `entries` governs the entry-count fields. A field
+ * uses ZIP64 (and gets the sentinel) exactly when its value is `>= threshold`,
+ * matching commons-compress's `>= ZIP64_MAGIC` / `>= ZIP64_MAGIC_SHORT`.
+ */
+export interface Zip64Thresholds {
+    size?: number;
+    entries?: number;
+}
+/**
+ * Package `baseDir` (an existing directory) into `<parent>/<name>.epub` beside
+ * it, overwriting any existing file there, and return the written path. The
+ * base directory is canonicalized first (Archive's makeCanonical), so a
+ * symlinked input saves next to the real directory. Throws on any failure; the
+ * caller maps that onto the jar's packaging-failure behavior.
+ *
+ * `thresholds` lets tests lower the ZIP64 trigger so the ZIP64 path runs on
+ * tiny inputs; it defaults to the real 32-bit/16-bit limits, keeping production
+ * output byte-identical to the pre-ZIP64 writer below 4 GB.
+ */
+export declare function createArchive(baseDir: string, thresholds?: Zip64Thresholds): Promise<string>;

package/dist/archive.js

@@ -0,0 +1,340 @@
+// Port of com.adobe.epubcheck.util.Archive (epubcheck 5.3.0) for the CLI's
+// `-s`/`--save` flag: package an expanded EPUB directory into
+// `<canonical-parent>/<directory-name>.epub`, laid out the way the jar's
+// commons-compress ZipArchiveOutputStream writes it.
+//
+// Faithful to the jar's observed output (verified against the real jar):
+// - Files are collected in RAW readdir order (Java's File.listFiles order).
+//   Node's fs.readdir would NOT match: libuv sorts scandir results, so this
+//   walks with the promises fs.opendir (uv_fs_opendir/readdir, NOT scandir),
+//   which preserves the on-disk order the jar sees -- the same raw order the old
+//   opendirSync gave, since async opendir uses the identical libuv directory API.
+// - `.DS_Store`, `._DS_Store`, `Thumbs.db`, `ehthumbs.db` files and `.svn`/
+//   `.git` directories are skipped (Archive.collectFiles, epubcheck issue 256).
+// - A root-level `mimetype` is moved to the front and STORED (method 0) with a
+//   precomputed CRC and NO extra fields; every other entry is DEFLATED.
+// - Entry names are UTF-8 with the language-encoding flag (0x0800) set, no
+//   unicode-path extra fields (setCreateUnicodeExtraFields(NEVER)).
+// - Deflated entries carry the same timestamp extra fields commons-compress
+//   emits from the file's real attributes: extended-timestamp 0x5455 (local:
+//   mtime/atime/birthtime seconds; central: mtime only) and NTFS 0x000a
+//   (mtime/atime/birthtime as 100 ns FILETIME values).
+// - Symlinks are followed (Java's File.isFile/isDirectory semantics); an entry
+//   that is neither a regular file nor a directory is skipped.
+//
+// One deliberate divergence, impossible to close from Node: the DEFLATED
+// streams differ byte-for-byte from the jar's because Node's bundled zlib and
+// the JDK's zlib produce different (both valid) output for the same input.
+// Entry order, names, methods, CRCs, sizes, and timestamps all match.
+//
+// ZIP64 (APPNOTE 6.3.x), emitted the way commons-compress's default
+// Zip64Mode.AsNeeded does on seekable output: classic 32-bit headers are used
+// until a field would actually overflow, and only then are ZIP64 structures
+// added -- per entry and at the end -- so a packaged form that needs more than
+// 4 GB of offset, a 4 GB+ entry, or 65535+ files produces a VALID archive
+// instead of throwing. The trigger crosses over when a size/offset reaches
+// 0xFFFFFFFF or the entry count reaches 0xFFFF (both overridable for tests via
+// the `createArchive` options, which default to the real limits):
+// - Per-entry ZIP64 extended-information extra field (id 0x0001), added only
+//   for the entry that needs it, placed FIRST among its extra fields
+//   (commons-compress's addAsFirstExtraField). The local header carries it when
+//   the entry's own size overflows and always writes BOTH 8-byte sizes
+//   (uncompressed then compressed); the central header carries only the values
+//   that overflow, in APPNOTE order (uncompressed size, compressed size,
+//   local-header offset), with the overflowing 32-bit fields set to the
+//   0xFFFFFFFF sentinel and version-needed bumped to 45.
+// - A ZIP64 end-of-central-directory record (0x06064b50, 56 bytes) + locator
+//   (0x07064b50, 20 bytes) before the classic EOCD once any entry used ZIP64 or
+//   the central-directory offset/size/entry-count would overflow; the classic
+//   EOCD then carries 0xFFFF / 0xFFFFFFFF sentinels in the overflowing fields.
+//
+// Standard for the ZIP64 path: STRUCTURE / field placement mirrors
+// commons-compress AsNeeded, NOT byte-identical output. Byte parity above 4 GB
+// was never achievable anyway -- our DEFLATE stream already differs from the
+// JDK's (see above) -- so the goal is a valid archive whose ZIP64 layout
+// matches the jar's, verified by round-tripping through an independent
+// ZIP64-aware reader. Below the threshold NO ZIP64 structures appear, so
+// sub-4 GB packaging stays byte-identical to the pre-ZIP64 output.
+import { opendir, readFile, realpath, stat, open } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { crc32, deflateRaw } from "node:zlib";
+import { promisify } from "node:util";
+// zlib exposes only a callback deflateRaw; promisify it so packaging runs on the
+// libuv thread pool without blocking the event loop (async law). Its output is
+// byte-identical to the old deflateRawSync -- same zlib, same default options, a
+// deterministic deflate stream -- which the save-parity structural test confirms.
+const deflateRawAsync = promisify(deflateRaw);
+const IGNORED_FILES = new Set([".DS_Store", "._DS_Store", "Thumbs.db", "ehthumbs.db"]);
+const IGNORED_DIRS = new Set([".svn", ".git"]);
+// Sentinel values written into the classic 32-bit / 16-bit fields to say "the
+// real value lives in a ZIP64 structure" (APPNOTE 4.3.9.2, 4.4.1.4). These are
+// ALSO the true overflow limits commons-compress uses as its AsNeeded trigger.
+const ZIP64_MAGIC = 0xffffffff;
+const ZIP64_MAGIC_SHORT = 0xffff;
+const ZIP64_VERSION = 45; // version-needed-to-extract for a ZIP64 entry/record
+/**
+ * ZIP64 local extended-information extra field (id 0x0001): commons-compress
+ * always writes BOTH the 8-byte uncompressed and 8-byte compressed size in the
+ * local extra when it adds one.
+ */
+function zip64LocalExtra(uncompressedSize, compressedSize) {
+    const b = Buffer.alloc(4 + 16);
+    b.writeUInt16LE(0x0001, 0);
+    b.writeUInt16LE(16, 2);
+    b.writeBigUInt64LE(BigInt(uncompressedSize), 4);
+    b.writeBigUInt64LE(BigInt(compressedSize), 12);
+    return b;
+}
+/**
+ * ZIP64 central extended-information extra field (id 0x0001): carries ONLY the
+ * values that overflow, in the fixed APPNOTE order (uncompressed size,
+ * compressed size, local-header offset), matching commons-compress's
+ * getCentralDirectoryData(). The two sizes are emitted together (both or
+ * neither) when either overflows; the offset is emitted when it overflows. The
+ * disk-start-number never overflows here (single disk), so it is never present.
+ */
+function zip64CentralExtra(needSizes, uncompressedSize, compressedSize, needOffset, offset) {
+    const dataLen = (needSizes ? 16 : 0) + (needOffset ? 8 : 0);
+    const b = Buffer.alloc(4 + dataLen);
+    b.writeUInt16LE(0x0001, 0);
+    b.writeUInt16LE(dataLen, 2);
+    let o = 4;
+    if (needSizes) {
+        b.writeBigUInt64LE(BigInt(uncompressedSize), o);
+        b.writeBigUInt64LE(BigInt(compressedSize), o + 8);
+        o += 16;
+    }
+    if (needOffset) {
+        b.writeBigUInt64LE(BigInt(offset), o);
+    }
+    return b;
+}
+/** Archive.collectFiles: depth-first, raw readdir order, junk entries skipped. */
+async function collectFiles(dir, dirName, out) {
+    // Drain the whole directory first (for-await auto-closes the Dir on
+    // completion), so only one directory handle is open at a time down the
+    // recursion. `for await` reads entries via the same libuv opendir/readdir the
+    // sync path used, preserving the raw (unsorted) order the jar's File.listFiles
+    // sees -- the byte-order the saved zip depends on.
+    const names = [];
+    const d = await opendir(dir);
+    for await (const ent of d)
+        names.push(ent.name);
+    for (const name of names) {
+        const full = join(dir, name);
+        let st;
+        try {
+            st = await stat(full); // follows symlinks, like java.io.File
+        }
+        catch {
+            continue; // dangling symlink: neither isFile nor isDirectory to Java
+        }
+        if (st.isFile()) {
+            if (!IGNORED_FILES.has(name))
+                out.push({ name: dirName + name, path: full });
+        }
+        else if (st.isDirectory()) {
+            if (!IGNORED_DIRS.has(name))
+                await collectFiles(full, dirName + name + "/", out);
+        }
+    }
+}
+/** MS-DOS date+time (local time, 2 s resolution) as (date << 16) | time. */
+function dosDateTime(ms) {
+    const d = new Date(ms);
+    if (d.getFullYear() < 1980)
+        return 0x0021 << 16; // 1980-01-01 00:00:00
+    const date = ((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
+    const time = (d.getHours() << 11) | (d.getMinutes() << 5) | (d.getSeconds() >> 1);
+    return ((date << 16) | time) >>> 0;
+}
+/** Windows FILETIME (100 ns intervals since 1601-01-01) from unix nanoseconds. */
+function toFiletime(ns) {
+    return ns / 100n + 116444736000000000n;
+}
+/** Unix seconds as the unsigned 32-bit value the 0x5455 field stores. */
+function toUnixSec(ns) {
+    return Number(BigInt.asUintN(32, ns / 1000000000n));
+}
+/** NTFS extra field 0x000a (36 bytes): mtime, atime, creation as FILETIME. */
+function writeNtfsExtra(b, off, st) {
+    b.writeUInt16LE(0x000a, off);
+    b.writeUInt16LE(32, off + 2);
+    b.writeUInt32LE(0, off + 4); // reserved
+    b.writeUInt16LE(0x0001, off + 8); // tag: times
+    b.writeUInt16LE(24, off + 10);
+    b.writeBigUInt64LE(toFiletime(st.mtimeNs), off + 12);
+    b.writeBigUInt64LE(toFiletime(st.atimeNs), off + 20);
+    b.writeBigUInt64LE(toFiletime(st.birthtimeNs), off + 28);
+}
+/** Local-header extra: 0x5455 (flags 7: mtime/atime/creation) + NTFS. */
+function localExtra(st) {
+    const b = Buffer.alloc(17 + 36);
+    b.writeUInt16LE(0x5455, 0);
+    b.writeUInt16LE(13, 2);
+    b.writeUInt8(0x07, 4);
+    b.writeUInt32LE(toUnixSec(st.mtimeNs), 5);
+    b.writeUInt32LE(toUnixSec(st.atimeNs), 9);
+    b.writeUInt32LE(toUnixSec(st.birthtimeNs), 13);
+    writeNtfsExtra(b, 17, st);
+    return b;
+}
+/** Central-directory extra: 0x5455 (flags 7, mtime only) + NTFS. */
+function centralExtra(st) {
+    const b = Buffer.alloc(9 + 36);
+    b.writeUInt16LE(0x5455, 0);
+    b.writeUInt16LE(5, 2);
+    b.writeUInt8(0x07, 4);
+    b.writeUInt32LE(toUnixSec(st.mtimeNs), 5);
+    writeNtfsExtra(b, 9, st);
+    return b;
+}
+/**
+ * Package `baseDir` (an existing directory) into `<parent>/<name>.epub` beside
+ * it, overwriting any existing file there, and return the written path. The
+ * base directory is canonicalized first (Archive's makeCanonical), so a
+ * symlinked input saves next to the real directory. Throws on any failure; the
+ * caller maps that onto the jar's packaging-failure behavior.
+ *
+ * `thresholds` lets tests lower the ZIP64 trigger so the ZIP64 path runs on
+ * tiny inputs; it defaults to the real 32-bit/16-bit limits, keeping production
+ * output byte-identical to the pre-ZIP64 writer below 4 GB.
+ */
+export async function createArchive(baseDir, thresholds = {}) {
+    const sizeThreshold = thresholds.size ?? ZIP64_MAGIC;
+    const entryThreshold = thresholds.entries ?? ZIP64_MAGIC_SHORT;
+    const canonical = await realpath(baseDir);
+    const epubFile = join(dirname(canonical), basename(canonical) + ".epub");
+    const entries = [];
+    await collectFiles(canonical, "", entries);
+    // Make a root-level mimetype the first entry; only then is one STORED.
+    const mimetypeIndex = entries.findIndex((e) => e.name === "mimetype");
+    if (mimetypeIndex > -1) {
+        const [m] = entries.splice(mimetypeIndex, 1);
+        entries.unshift(m);
+    }
+    const fd = await open(epubFile, "w");
+    try {
+        let offset = 0;
+        const central = [];
+        // Set once any entry emits a ZIP64 extra: it forces the ZIP64 EOCD, exactly
+        // like commons-compress's hasUsedZip64 flag (independent of whether the
+        // central-directory offset/size/count themselves overflow).
+        let usedZip64 = false;
+        for (let i = 0; i < entries.length; i++) {
+            const e = entries[i];
+            const st = await stat(e.path, { bigint: true }); // attrs BEFORE the read, like the jar
+            const data = await readFile(e.path);
+            const stored = i === 0 && mimetypeIndex > -1;
+            const comp = stored ? data : await deflateRawAsync(data);
+            // crc32 is a synchronous pure-CPU checksum with no async equivalent
+            // (async law's pure-CPU exemption); it runs on the already-in-memory buffer.
+            const crc = crc32(data);
+            const name = Buffer.from(e.name, "utf8");
+            const dos = dosDateTime(Number(st.mtimeNs / 1000000n));
+            const method = stored ? 0 : 8;
+            // AsNeeded ZIP64 decision, per field. The local header carries a ZIP64
+            // extra (both sizes) when the entry's own size overflows; the central
+            // header additionally carries the local-header offset when THAT overflows.
+            // The local header has no offset field, so an offset-only overflow leaves
+            // the local header classic (version 20, real 32-bit sizes) -- exactly what
+            // commons-compress does, since it only learns the offset overflow while
+            // building the central header.
+            const needSizes = data.length >= sizeThreshold || comp.length >= sizeThreshold;
+            const needOffset = offset >= sizeThreshold;
+            if (needSizes || needOffset)
+                usedZip64 = true;
+            const baseExtraL = stored ? Buffer.alloc(0) : localExtra(st);
+            const baseExtraC = stored ? Buffer.alloc(0) : centralExtra(st);
+            const extraL = needSizes
+                ? Buffer.concat([zip64LocalExtra(data.length, comp.length), baseExtraL])
+                : baseExtraL;
+            const extraC = needSizes || needOffset
+                ? Buffer.concat([
+                    zip64CentralExtra(needSizes, data.length, comp.length, needOffset, offset),
+                    baseExtraC,
+                ])
+                : baseExtraC;
+            const classicVersion = stored ? 10 : 20;
+            const localVersion = needSizes ? ZIP64_VERSION : classicVersion;
+            const centralVersion = needSizes || needOffset ? ZIP64_VERSION : classicVersion;
+            const lfhComp = needSizes ? ZIP64_MAGIC : comp.length;
+            const lfhUncomp = needSizes ? ZIP64_MAGIC : data.length;
+            const lfh = Buffer.alloc(30);
+            lfh.writeUInt32LE(0x04034b50, 0);
+            lfh.writeUInt16LE(localVersion, 4);
+            lfh.writeUInt16LE(0x0800, 6); // UTF-8 names
+            lfh.writeUInt16LE(method, 8);
+            lfh.writeUInt32LE(dos, 10);
+            lfh.writeUInt32LE(crc, 14);
+            lfh.writeUInt32LE(lfhComp, 18);
+            lfh.writeUInt32LE(lfhUncomp, 22);
+            lfh.writeUInt16LE(name.length, 26);
+            lfh.writeUInt16LE(extraL.length, 28);
+            const cen = Buffer.alloc(46);
+            cen.writeUInt32LE(0x02014b50, 0);
+            cen.writeUInt16LE(20, 4); // version made by: 2.0, FAT
+            cen.writeUInt16LE(centralVersion, 6);
+            cen.writeUInt16LE(0x0800, 8);
+            cen.writeUInt16LE(method, 10);
+            cen.writeUInt32LE(dos, 12);
+            cen.writeUInt32LE(crc, 16);
+            cen.writeUInt32LE(needSizes ? ZIP64_MAGIC : comp.length, 20);
+            cen.writeUInt32LE(needSizes ? ZIP64_MAGIC : data.length, 24);
+            cen.writeUInt16LE(name.length, 28);
+            cen.writeUInt16LE(extraC.length, 30);
+            // comment length, disk start, internal and external attributes: all 0
+            cen.writeUInt32LE(needOffset ? ZIP64_MAGIC : offset, 42);
+            central.push(cen, name, extraC);
+            await fd.write(lfh);
+            await fd.write(name);
+            await fd.write(extraL);
+            await fd.write(comp);
+            offset += lfh.length + name.length + extraL.length + comp.length;
+        }
+        const cdOffset = offset;
+        let cdSize = 0;
+        for (const b of central) {
+            await fd.write(b);
+            cdSize += b.length;
+        }
+        // ZIP64 EOCD record + locator (commons-compress writeZip64CentralDirectory):
+        // written when any entry used ZIP64 or the central-directory offset/size or
+        // entry count would overflow the classic 32-bit/16-bit EOCD fields.
+        const eocdOffsetOverflow = cdOffset >= sizeThreshold;
+        const eocdSizeOverflow = cdSize >= sizeThreshold;
+        const eocdCountOverflow = entries.length >= entryThreshold;
+        if (usedZip64 || eocdOffsetOverflow || eocdSizeOverflow || eocdCountOverflow) {
+            const z64eocd = Buffer.alloc(56);
+            z64eocd.writeUInt32LE(0x06064b50, 0);
+            z64eocd.writeBigUInt64LE(44n, 4); // size of the remainder of this record (56 - 12)
+            z64eocd.writeUInt16LE(ZIP64_VERSION, 12); // version made by
+            z64eocd.writeUInt16LE(ZIP64_VERSION, 14); // version needed to extract
+            z64eocd.writeUInt32LE(0, 16); // number of this disk
+            z64eocd.writeUInt32LE(0, 20); // disk with the start of the central directory
+            z64eocd.writeBigUInt64LE(BigInt(entries.length), 24); // entries on this disk
+            z64eocd.writeBigUInt64LE(BigInt(entries.length), 32); // total entries
+            z64eocd.writeBigUInt64LE(BigInt(cdSize), 40); // size of the central directory
+            z64eocd.writeBigUInt64LE(BigInt(cdOffset), 48); // offset of the central directory
+            await fd.write(z64eocd);
+            const z64loc = Buffer.alloc(20);
+            z64loc.writeUInt32LE(0x07064b50, 0);
+            z64loc.writeUInt32LE(0, 4); // disk with the ZIP64 EOCD record
+            z64loc.writeBigUInt64LE(BigInt(cdOffset + cdSize), 8); // offset of the ZIP64 EOCD record
+            z64loc.writeUInt32LE(1, 16); // total number of disks
+            await fd.write(z64loc);
+        }
+        const eocdCount = eocdCountOverflow ? ZIP64_MAGIC_SHORT : entries.length;
+        const eocd = Buffer.alloc(22);
+        eocd.writeUInt32LE(0x06054b50, 0);
+        eocd.writeUInt16LE(eocdCount, 8);
+        eocd.writeUInt16LE(eocdCount, 10);
+        eocd.writeUInt32LE(eocdSizeOverflow ? ZIP64_MAGIC : cdSize, 12);
+        eocd.writeUInt32LE(eocdOffsetOverflow ? ZIP64_MAGIC : cdOffset, 16);
+        await fd.write(eocd);
+    }
+    finally {
+        await fd.close();
+    }
+    return epubFile;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function run(args: string[]): Promise<number>;