@nexlibris/crosspoint-tools 0.0.0-stage → 0.1.0

package/stardict.d.ts

@@ -0,0 +1,41 @@
+/**
+ * StarDict dictionaries for CrossPoint (crosspoint-reader's docs/dictionary.md): one folder per
+ * dictionary under `/dictionaries`, holding an uncompressed `.idx`, a `.dict` or `.dict.dz`, and
+ * optionally a `.syn` and `.ifo`. Picked files are sorted into dictionaries here: archives (zip,
+ * tar, tar.gz) are unpacked and a gzipped `.idx` decompressed, which the reader can't do.
+ */
+/** Where dictionaries go, and the hidden root the reader also reads. */
+export declare const DICTIONARY_ROOT = "/dictionaries";
+export declare const HIDDEN_DICTIONARY_ROOT = "/.dictionaries";
+export interface DictionaryFile {
+    name: string;
+    data: Blob;
+}
+export interface PreparedDictionary {
+    /** The folder's name, which the reader shows on its tabs. */
+    name: string;
+    /** The `.ifo`'s name for it, if it has one. */
+    title?: string;
+    words?: number;
+    files: DictionaryFile[];
+}
+export interface Prepared {
+    dictionaries: PreparedDictionary[];
+    /** Files or groups that couldn't be used, and why. */
+    problems: string[];
+}
+/** A picked file, with the folders it was in (`webkitRelativePath`) when a folder was picked. */
+export interface PickedFile {
+    path: string;
+    data: Blob;
+}
+/** A name the reader takes for a folder: no slashes or odd characters. */
+export declare const folderName: (text: string) => string;
+/** An `.ifo`'s `key=value` lines. */
+export declare function parseIfo(text: string): Record<string, string>;
+/** A tar archive's files (ustar, with GNU long names). Exported for tests. */
+export declare function untar(bytes: Uint8Array<ArrayBuffer>): PickedFile[];
+/** Sorts picked files (loose, in folders, or in archives) into dictionaries ready to copy to the reader. */
+export declare function prepareDictionaries(picked: PickedFile[]): Promise<Prepared>;
+/** Files the reader makes beside a dictionary's, and rebuilds when they're gone. */
+export declare const isSidecar: (name: string) => boolean;

package/stardict.js

@@ -0,0 +1,172 @@
+import JSZip from "jszip";
+//#region crosspoint-tools/src/stardict.ts
+/**
+* StarDict dictionaries for CrossPoint (crosspoint-reader's docs/dictionary.md): one folder per
+* dictionary under `/dictionaries`, holding an uncompressed `.idx`, a `.dict` or `.dict.dz`, and
+* optionally a `.syn` and `.ifo`. Picked files are sorted into dictionaries here: archives (zip,
+* tar, tar.gz) are unpacked and a gzipped `.idx` decompressed, which the reader can't do.
+*/
+/** Where dictionaries go, and the hidden root the reader also reads. */
+const DICTIONARY_ROOT = "/dictionaries";
+const HIDDEN_DICTIONARY_ROOT = "/.dictionaries";
+/** A dictionary file's role, by the end of its name. */
+const PARTS = [
+	[/\.idx\.gz$/i, "idx.gz"],
+	[/\.idx$/i, "idx"],
+	[/\.dict\.dz$/i, "dict.dz"],
+	[/\.dict$/i, "dict"],
+	[/\.syn$/i, "syn"],
+	[/\.ifo$/i, "ifo"]
+];
+function part(name) {
+	for (const [pattern, kind] of PARTS) if (pattern.test(name)) return {
+		stem: name.replace(pattern, ""),
+		kind
+	};
+}
+/** A name the reader takes for a folder: no slashes or odd characters. */
+const folderName = (text) => text.replace(/[^\w\-. ]+/g, "").replace(/^\.+/, "").trim().slice(0, 48) || "dictionary";
+/** An `.ifo`'s `key=value` lines. */
+function parseIfo(text) {
+	const fields = {};
+	for (const line of text.split(/\r?\n/)) {
+		const at = line.indexOf("=");
+		if (at > 0) fields[line.slice(0, at).trim()] = line.slice(at + 1).trim();
+	}
+	return fields;
+}
+async function gunzip(data) {
+	return new Response(data.stream().pipeThrough(new DecompressionStream("gzip"))).blob();
+}
+const text = (bytes, start, length) => {
+	const slice = bytes.subarray(start, start + length);
+	const end = slice.indexOf(0);
+	return new TextDecoder().decode(end < 0 ? slice : slice.subarray(0, end));
+};
+/** A tar archive's files (ustar, with GNU long names). Exported for tests. */
+function untar(bytes) {
+	const files = [];
+	let longName;
+	for (let at = 0; at + 512 <= bytes.length;) {
+		const name = text(bytes, at, 100);
+		if (!name) break;
+		const size = parseInt(text(bytes, at + 124, 12).trim() || "0", 8);
+		const type = String.fromCharCode(bytes[at + 156]);
+		const prefix = text(bytes, at + 345, 155);
+		const body = bytes.slice(at + 512, at + 512 + size);
+		if (type === "L") longName = text(body, 0, size);
+		else {
+			if (type === "0" || type === "\0") files.push({
+				path: longName ?? (prefix ? `${prefix}/${name}` : name),
+				data: new Blob([body])
+			});
+			longName = void 0;
+		}
+		at += 512 + Math.ceil(size / 512) * 512;
+	}
+	return files;
+}
+/** Picked files with any archives among them unpacked. */
+async function unpack(picked, problems) {
+	const files = [];
+	for (const file of picked) {
+		const lower = file.path.toLowerCase();
+		try {
+			if (lower.endsWith(".zip")) {
+				const zip = await JSZip.loadAsync(await file.data.arrayBuffer());
+				for (const entry of Object.values(zip.files)) if (!entry.dir) files.push({
+					path: entry.name,
+					data: await entry.async("blob")
+				});
+			} else if (/\.(tar\.gz|tgz)$/.test(lower)) files.push(...untar(new Uint8Array(await (await gunzip(file.data)).arrayBuffer())));
+			else if (lower.endsWith(".tar")) files.push(...untar(new Uint8Array(await file.data.arrayBuffer())));
+			else if (/\.(tar\.bz2|tbz2?|tar\.xz|7z|rar)$/.test(lower)) problems.push(`${baseName(file.path)}: unpack this on your computer first; nexlibris reads zip, tar and tar.gz.`);
+			else files.push(file);
+		} catch {
+			problems.push(`${baseName(file.path)}: couldn’t be unpacked.`);
+		}
+	}
+	return files;
+}
+const baseName = (path) => path.slice(path.lastIndexOf("/") + 1);
+const folderOf = (path) => path.slice(0, Math.max(0, path.lastIndexOf("/")));
+/** Sorts picked files (loose, in folders, or in archives) into dictionaries ready to copy to the reader. */
+async function prepareDictionaries(picked) {
+	const problems = [];
+	const files = await unpack(picked, problems);
+	const groups = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const name = baseName(file.path);
+		const found = part(name);
+		if (!found || name.startsWith(".")) continue;
+		const folder = folderOf(file.path);
+		const key = `${folder}\n${found.stem}`;
+		const group = groups.get(key) ?? {
+			folder,
+			stem: found.stem,
+			parts: /* @__PURE__ */ new Map()
+		};
+		group.parts.set(found.kind, file);
+		groups.set(key, group);
+	}
+	const dictionaries = [];
+	const stemsIn = (folder) => [...groups.values()].filter((g) => g.folder === folder).length;
+	for (const { folder, stem, parts } of groups.values()) {
+		const label = stem || baseName(folder);
+		const idx = parts.get("idx") ?? parts.get("idx.gz");
+		const dict = parts.get("dict.dz") ?? parts.get("dict");
+		if (!idx || !dict) {
+			problems.push(`${label}: a dictionary needs its ${idx ? ".dict or .dict.dz" : ".idx"} file too.`);
+			continue;
+		}
+		const ifoFile = parts.get("ifo");
+		const ifo = ifoFile ? parseIfo(await ifoFile.data.text()) : {};
+		if (ifo.idxoffsetbits === "64") {
+			problems.push(`${label}: uses 64-bit offsets, which CrossPoint can’t read.`);
+			continue;
+		}
+		let index;
+		try {
+			index = parts.has("idx") ? {
+				name: `${stem}.idx`,
+				data: idx.data
+			} : {
+				name: `${stem}.idx`,
+				data: await gunzip(idx.data)
+			};
+		} catch {
+			problems.push(`${label}: its .idx.gz couldn’t be decompressed.`);
+			continue;
+		}
+		const kept = [index, {
+			name: baseName(dict.path),
+			data: dict.data
+		}];
+		const syn = parts.get("syn");
+		if (syn) kept.push({
+			name: baseName(syn.path),
+			data: syn.data
+		});
+		if (ifoFile) kept.push({
+			name: baseName(ifoFile.path),
+			data: ifoFile.data
+		});
+		const name = folderName(folder && stemsIn(folder) === 1 ? baseName(folder) : stem);
+		const words = Number(ifo.wordcount);
+		dictionaries.push({
+			name,
+			...ifo.bookname && { title: ifo.bookname },
+			...Number.isFinite(words) && words > 0 && { words },
+			files: kept
+		});
+	}
+	if (!dictionaries.length && !problems.length) problems.push("No StarDict dictionary (.idx and .dict files) was found in what was picked.");
+	return {
+		dictionaries,
+		problems
+	};
+}
+/** Files the reader makes beside a dictionary's, and rebuilds when they're gone. */
+const isSidecar = (name) => /\.(qidx|sidx)$/i.test(name);
+//#endregion
+export { DICTIONARY_ROOT, HIDDEN_DICTIONARY_ROOT, folderName, isSidecar, parseIfo, prepareDictionaries, untar };

package/xteink/image.d.ts

@@ -0,0 +1,54 @@
+import type { ImageOptions } from './options';
+export { DEFAULT_IMAGE_OPTIONS, type ImageOptions } from './options';
+/**
+ * Image optimization for CrossPoint readers, ported from `process_image` in the
+ * CrossPoint Calibre plugins' `optimizer.py` (MIT), itself a port of the
+ * device web UI's canvas pipeline: optional auto-crop of uniform margins, scale
+ * to fit the screen, flatten transparency onto white, grayscale, baseline JPEG.
+ */
+export interface Profile {
+    label: string;
+    /** Short and long edge, portrait. */
+    width: number;
+    height: number;
+}
+export declare const PROFILES: {
+    X4: {
+        label: string;
+        width: number;
+        height: number;
+    };
+    X3: {
+        label: string;
+        width: number;
+        height: number;
+    };
+};
+/** RGBA pixels, as from `getImageData`. */
+export interface Pixels {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+}
+export interface Box {
+    left: number;
+    top: number;
+    /** Exclusive. */
+    right: number;
+    bottom: number;
+}
+/** The box trimming an image's uniform margins, or undefined when cropping isn't worth it. */
+export declare function findCropBox(pixels: Pixels): Box | undefined;
+export declare function shouldSkipAutoCrop(path: string, width: number, height: number): boolean;
+/**
+ * The size to draw at: fitted to the screen, keeping the aspect ratio. An image that already fits is kept as it
+ * is, unless it was cropped, which scales it up to fill the screen.
+ */
+export declare function fitSize(width: number, height: number, profile: Profile, cropped: boolean): {
+    width: number;
+    height: number;
+};
+/** Flattens onto white and, optionally, converts to grayscale with ITU-R 601 luma (as the device's web UI does). */
+export declare function flattenPixels({ data }: Pixels, grayscale: boolean): void;
+/** Optimizes one image with the browser's decoder and canvas. Throws if the image can't be decoded. */
+export declare function processImage(data: Uint8Array, path: string, profile: Profile, options: ImageOptions): Promise<Uint8Array>;

package/xteink/image.js

@@ -0,0 +1,202 @@
+import { DEFAULT_IMAGE_OPTIONS } from "./options.js";
+//#region crosspoint-tools/src/xteink/image.ts
+const PROFILES = {
+	X4: {
+		label: "X4",
+		width: 480,
+		height: 800
+	},
+	X3: {
+		label: "X3",
+		width: 528,
+		height: 792
+	}
+};
+const CROP_WHITE_THRESHOLD = 245;
+const CROP_BACKGROUND_TOLERANCE = 28;
+const CROP_BACKGROUND_MAX_SPREAD = 24;
+const CROP_EDGE_SAMPLE_SIZE = 12;
+const CROP_PADDING_PX = 8;
+const MIN_CROP_SAVINGS_RATIO = .08;
+const MIN_COLOR_CROP_SAVINGS_RATIO = .2;
+const MIN_CROP_DIMENSION = 240;
+const COVER_NAME_RE = /(^|\/)(cover|thumbnail|thumb|icon)[^/]*\.(jpe?g|png|gif|webp|bmp)$/i;
+/** A pixel composited onto white. */
+function flattened(data, i) {
+	const a = data[i + 3] / 255;
+	return [
+		0,
+		1,
+		2
+	].map((c) => data[i + c] * a + 255 * (1 - a));
+}
+/** The mean colour of the edges, sampled in eight places, or undefined if they differ (no uniform margin). */
+function estimateCropBackground({ width, height, data }) {
+	const sample = Math.min(CROP_EDGE_SAMPLE_SIZE, Math.floor(width / 8), Math.floor(height / 8));
+	if (sample < 2) return void 0;
+	const midX = Math.floor((width - sample) / 2);
+	const midY = Math.floor((height - sample) / 2);
+	const means = [
+		[0, 0],
+		[width - sample, 0],
+		[0, height - sample],
+		[width - sample, height - sample],
+		[midX, 0],
+		[midX, height - sample],
+		[0, midY],
+		[width - sample, midY]
+	].map(([x0, y0]) => {
+		const sum = [
+			0,
+			0,
+			0
+		];
+		for (let y = y0; y < y0 + sample; y++) for (let x = x0; x < x0 + sample; x++) {
+			const px = flattened(data, (y * width + x) * 4);
+			for (let c = 0; c < 3; c++) sum[c] += px[c];
+		}
+		return sum.map((s) => s / (sample * sample));
+	});
+	const average = [
+		0,
+		1,
+		2
+	].map((c) => means.reduce((s, m) => s + m[c], 0) / means.length);
+	return Math.max(...means.flatMap((m) => m.map((v, c) => Math.abs(v - average[c])))) > CROP_BACKGROUND_MAX_SPREAD ? void 0 : average;
+}
+/** The box trimming an image's uniform margins, or undefined when cropping isn't worth it. */
+function findCropBox(pixels) {
+	const { width, height, data } = pixels;
+	const background = estimateCropBackground(pixels);
+	const [r0, g0, b0] = background?.map(Math.round) ?? [];
+	const isContent = (i) => {
+		const a = data[i + 3] / 255;
+		const r = Math.round(data[i] * a + 255 * (1 - a));
+		const g = Math.round(data[i + 1] * a + 255 * (1 - a));
+		const b = Math.round(data[i + 2] * a + 255 * (1 - a));
+		if (r0 === void 0) return r < CROP_WHITE_THRESHOLD || g < CROP_WHITE_THRESHOLD || b < CROP_WHITE_THRESHOLD;
+		const t = CROP_BACKGROUND_TOLERANCE;
+		return Math.abs(r - r0) > t || Math.abs(g - g0) > t || Math.abs(b - b0) > t;
+	};
+	let left = width;
+	let top = height;
+	let right = 0;
+	let bottom = 0;
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		if (!isContent((y * width + x) * 4)) continue;
+		left = Math.min(left, x);
+		top = Math.min(top, y);
+		right = Math.max(right, x + 1);
+		bottom = Math.max(bottom, y + 1);
+	}
+	if (right === 0) return void 0;
+	const box = {
+		left: Math.max(0, left - CROP_PADDING_PX),
+		top: Math.max(0, top - CROP_PADDING_PX),
+		right: Math.min(width, right + CROP_PADDING_PX),
+		bottom: Math.min(height, bottom + CROP_PADDING_PX)
+	};
+	const saved = 1 - (box.right - box.left) * (box.bottom - box.top) / (width * height);
+	const nearWhite = background?.every((c) => c >= CROP_WHITE_THRESHOLD);
+	return saved < (!background || nearWhite ? MIN_CROP_SAVINGS_RATIO : MIN_COLOR_CROP_SAVINGS_RATIO) ? void 0 : box;
+}
+function shouldSkipAutoCrop(path, width, height) {
+	return width < MIN_CROP_DIMENSION || height < MIN_CROP_DIMENSION || COVER_NAME_RE.test(path);
+}
+/**
+* The size to draw at: fitted to the screen, keeping the aspect ratio. An image that already fits is kept as it
+* is, unless it was cropped, which scales it up to fill the screen.
+*/
+function fitSize(width, height, profile, cropped) {
+	if (width <= profile.width && height <= profile.height && !cropped) return {
+		width,
+		height
+	};
+	const scale = Math.min(profile.width / width, profile.height / height);
+	return {
+		width: Math.max(1, Math.round(width * scale)),
+		height: Math.max(1, Math.round(height * scale))
+	};
+}
+/** Flattens onto white and, optionally, converts to grayscale with ITU-R 601 luma (as the device's web UI does). */
+function flattenPixels({ data }, grayscale) {
+	for (let i = 0; i < data.length; i += 4) {
+		const [r, g, b] = flattened(data, i);
+		if (grayscale) {
+			const luma = .299 * r + .587 * g + .114 * b;
+			data[i] = data[i + 1] = data[i + 2] = luma;
+		} else {
+			data[i] = r;
+			data[i + 1] = g;
+			data[i + 2] = b;
+		}
+		data[i + 3] = 255;
+	}
+}
+/** Optimizes one image with the browser's decoder and canvas. Throws if the image can't be decoded. */
+async function processImage(data, path, profile, options) {
+	const source = await createImageBitmap(new Blob([data]));
+	try {
+		let crop = {
+			left: 0,
+			top: 0,
+			right: source.width,
+			bottom: source.height
+		};
+		let cropped = false;
+		if (options.autoCrop && !shouldSkipAutoCrop(path, source.width, source.height)) {
+			const full = canvas(source.width, source.height);
+			full.context.drawImage(source, 0, 0);
+			const box = findCropBox(full.context.getImageData(0, 0, source.width, source.height));
+			if (box) {
+				crop = box;
+				cropped = true;
+			}
+		}
+		const size = fitSize(crop.right - crop.left, crop.bottom - crop.top, profile, cropped);
+		const out = canvas(size.width, size.height);
+		out.context.imageSmoothingQuality = "high";
+		out.context.drawImage(source, crop.left, crop.top, crop.right - crop.left, crop.bottom - crop.top, 0, 0, size.width, size.height);
+		const pixels = out.context.getImageData(0, 0, size.width, size.height);
+		flattenPixels(pixels, options.grayscale);
+		out.context.putImageData(pixels, 0, 0);
+		const jpeg = await out.toBlob("image/jpeg", options.quality / 100);
+		return new Uint8Array(await jpeg.arrayBuffer());
+	} finally {
+		source.close();
+	}
+}
+/**
+* A canvas to draw on and encode from. On a page it's a `<canvas>`, encoded with the synchronous `toDataURL`:
+* Chrome defers async encoding (`toBlob`, `convertToBlob`) in background tabs to about one a second, which made
+* a sync left running in another tab crawl. In a worker, where there's no DOM, it's an OffscreenCanvas.
+*/
+function canvas(width, height) {
+	if (typeof document === "undefined") {
+		const c = new OffscreenCanvas(width, height);
+		const context = c.getContext("2d", { willReadFrequently: true });
+		if (!context) throw new Error("No 2D canvas");
+		return {
+			context,
+			toBlob: (type, quality) => c.convertToBlob({
+				type,
+				quality
+			})
+		};
+	}
+	const c = document.createElement("canvas");
+	c.width = width;
+	c.height = height;
+	const context = c.getContext("2d", { willReadFrequently: true });
+	if (!context) throw new Error("No 2D canvas");
+	return {
+		context,
+		toBlob: async (type, quality) => {
+			const url = c.toDataURL(type, quality);
+			const binary = atob(url.slice(url.indexOf(",") + 1));
+			return new Blob([Uint8Array.from(binary, (c) => c.charCodeAt(0))], { type });
+		}
+	};
+}
+//#endregion
+export { DEFAULT_IMAGE_OPTIONS, PROFILES, findCropBox, fitSize, flattenPixels, processImage, shouldSkipAutoCrop };

package/xteink/optimize.d.ts

@@ -0,0 +1,33 @@
+import { type Profile } from './image';
+import { type OptimizeOptions } from './options';
+/**
+ * Optimizes an EPUB for a CrossPoint reader (Xteink X4/X3), ported from
+ * `crosspoint_reader/optimizer.py` in the CrossPoint Calibre plugins (MIT),
+ * which mirrors the device web UI's optimizer:
+ *
+ * - every raster image is re-encoded for the screen (see `image.ts`) and renamed `.jpg`;
+ * - markup is fixed up: references renamed, stale `<img>` sizes stripped,
+ *   SVG-wrapped images unwrapped, a small defensive stylesheet injected;
+ * - the OPF gets JPEG media types, no `svg` properties and a cover meta; the NCX's
+ *   identifier is synced with the OPF's;
+ * - then the text passes (`textsplit.ts`) split what the firmware can't hold in RAM.
+ *
+ * Markup is rewritten with string operations (the Python's fallback path), so
+ * anything not being fixed stays byte-for-byte as it was.
+ */
+export { DEFAULT_OPTIMIZE_OPTIONS, type OptimizeOptions } from './options';
+export type ImageProcessor = (data: Uint8Array, path: string) => Promise<Uint8Array>;
+export declare const DEFENSIVE_STYLE: string;
+export declare function optimizeEpub(data: Blob, profile: Profile, options?: OptimizeOptions, image?: ImageProcessor, log?: (message: string) => void): Promise<Blob>;
+/** UTF-8 (without a BOM), or else the encoding the XML declaration or meta charset names. */
+export declare function decodeText(raw: Uint8Array): string;
+export declare const renameRefs: (text: string) => string;
+/** Removes width and height (attributes and inline styles) from every `<img>`. */
+export declare function stripImgDimensions(text: string): string;
+/** Replaces SVG-wrapped images (common for covers), which the firmware can't render, with plain `<img>`s. */
+export declare function unwrapSvgImages(text: string): string;
+export declare function fixXhtml(text: string): string;
+/** JPEG media types for renamed images, no `svg` properties, and a cover meta pointing at the cover image. */
+export declare function fixOpf(text: string): string;
+export declare function extractIdentifier(opf: string): string | undefined;
+export declare function syncNcxIdentifier(ncx: string, identifier: string | undefined): string;

package/xteink/optimize.js

@@ -0,0 +1,157 @@
+import { DEFAULT_OPTIMIZE_OPTIONS } from "./options.js";
+import { processImage } from "./image.js";
+import { basename, splitEpubText } from "./textsplit.js";
+import JSZip from "jszip";
+import { parseXml } from "@nexlibris/tools/formats/xml";
+//#region crosspoint-tools/src/xteink/optimize.ts
+const RASTER_RE = /\.(png|gif|webp|bmp|jpe?g)$/i;
+/** A whole path or attribute value to rename. */
+const RENAME_RE = /\.(png|gif|webp|bmp|jpeg)$/i;
+/** References inside markup and CSS (href, src, url(…)). */
+const REF_RE = /\.(?:png|gif|webp|bmp|jpeg)(?=["')\s#?>])/gi;
+const XHTML_RE = /\.(xhtml|html|htm)$/i;
+const DEFENSIVE_STYLE = "<style type=\"text/css\">img,svg{max-width:100%;height:auto}body{overflow-wrap:break-word}table{max-width:100%;table-layout:fixed}pre,code{white-space:pre-wrap;word-wrap:break-word}*{box-sizing:border-box}</style>";
+async function optimizeEpub(data, profile, options = DEFAULT_OPTIMIZE_OPTIONS, image = (bytes, path) => processImage(bytes, path, profile, options), log = () => void 0) {
+	const zip = await JSZip.loadAsync(await data.arrayBuffer());
+	const order = [];
+	zip.forEach((path, file) => {
+		if (!file.dir && path !== "mimetype") order.push(path);
+	});
+	const opfPath = await rootfilePath(zip) ?? order.find((p) => p.toLowerCase().endsWith(".opf"));
+	if (!opfPath) throw new Error("The EPUB has no package document.");
+	const identifier = extractIdentifier(decodeText(await zip.file(opfPath).async("uint8array")));
+	const entries = {
+		order: [],
+		data: /* @__PURE__ */ new Map(),
+		opfPath
+	};
+	const add = (path, value) => {
+		if (!entries.data.has(path)) entries.order.push(path);
+		entries.data.set(path, value);
+	};
+	for (const path of order) {
+		const raw = await zip.file(path).async("uint8array");
+		const lower = path.toLowerCase();
+		if (RASTER_RE.test(lower)) {
+			const renamed = path.replace(RENAME_RE, ".jpg");
+			try {
+				add(renamed, await image(raw, path));
+			} catch (e) {
+				log(`${basename(path)}: kept as it was (${e instanceof Error ? e.message : e})`);
+				add(renamed, raw);
+			}
+		} else if (XHTML_RE.test(lower)) add(path, fixXhtml(decodeText(raw)));
+		else if (path === opfPath) add(path, fixOpf(renameRefs(decodeText(raw))));
+		else if (lower.endsWith(".ncx")) add(path, syncNcxIdentifier(renameRefs(decodeText(raw)), identifier));
+		else if (lower.endsWith(".css")) add(path, renameRefs(decodeText(raw)));
+		else add(path, raw);
+	}
+	try {
+		const split = {
+			paragraphs: options.splitParagraphs,
+			chapters: options.splitChapters
+		};
+		await splitEpubText(entries, (bytes, name) => image(bytes, name), log, split);
+	} catch (e) {
+		log(`text splitting skipped: ${e instanceof Error ? e.message : e}`);
+	}
+	const out = new JSZip();
+	out.file("mimetype", "application/epub+zip", { compression: "STORE" });
+	for (const path of entries.order) {
+		const stored = /\.jpe?g$/i.test(path);
+		out.file(path, entries.data.get(path), {
+			compression: stored ? "STORE" : "DEFLATE",
+			createFolders: false
+		});
+	}
+	return out.generateAsync({
+		type: "blob",
+		mimeType: "application/epub+zip"
+	});
+}
+async function rootfilePath(zip) {
+	const container = Object.keys(zip.files).find((p) => p.toLowerCase() === "meta-inf/container.xml");
+	const xml = container && await zip.file(container).async("string");
+	const path = xml ? /<rootfile[^>]+full-path=["']([^"']+)["']/i.exec(xml)?.[1] : void 0;
+	return path && zip.file(path) ? path : void 0;
+}
+/** UTF-8 (without a BOM), or else the encoding the XML declaration or meta charset names. */
+function decodeText(raw) {
+	const bytes = raw[0] === 239 && raw[1] === 187 && raw[2] === 191 ? raw.subarray(3) : raw;
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		const head = new TextDecoder("ascii").decode(bytes.subarray(0, 512));
+		const encoding = (/encoding=["']([^"']+)["']/i.exec(head) ?? /charset=["']?([^"'\s;]+)/i.exec(head))?.[1];
+		try {
+			return new TextDecoder(encoding ?? "windows-1252").decode(bytes);
+		} catch {
+			return new TextDecoder("iso-8859-1").decode(bytes);
+		}
+	}
+}
+const renameRefs = (text) => text.replace(REF_RE, ".jpg");
+const STYLE_DECLARATION_RE = /(?:^|(?<=;))(\s*)([-_a-zA-Z][-_a-zA-Z0-9]*)\s*:((?:[^;"'()]|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^()\\])*\))*)(\s*)(;?)/g;
+/** Drops width and height from an inline style, which were set for the image before it was resized. */
+function stripSizeDeclarations(style) {
+	return style.replace(STYLE_DECLARATION_RE, (m, _lead, property) => ["width", "height"].includes(property.trim().toLowerCase()) ? "" : m);
+}
+/** Removes width and height (attributes and inline styles) from every `<img>`. */
+function stripImgDimensions(text) {
+	return text.replace(/<img\b[^>]*>/gi, (tag) => tag.replace(/\s+(?:width|height)\s*=\s*"[^"]*"/gi, "").replace(/\s+(?:width|height)\s*=\s*'[^']*'/gi, "").replace(/\s+style=(["'])([\s\S]*?)\1/gi, (m, quote, style) => {
+		const fixed = stripSizeDeclarations(style);
+		if (fixed === style) return m;
+		return fixed.trim() ? ` style=${quote}${fixed}${quote}` : "";
+	}));
+}
+const SVG_IMAGE_RE = /<(?:svg:)?svg\b[^>]*>[\s\S]*?<(?:svg:)?image\b[^>]*?(?:xlink:href|href)=["']([^"']+)["'][\s\S]*?<\/(?:svg:)?svg>/gi;
+/** Replaces SVG-wrapped images (common for covers), which the firmware can't render, with plain `<img>`s. */
+function unwrapSvgImages(text) {
+	if (!text.includes("<svg") || !text.includes("href")) return text;
+	return text.replace(SVG_IMAGE_RE, (_m, href) => `<img style="max-width:100%;height:auto" src="${href.replace(RENAME_RE, ".jpg")}" alt="" />`);
+}
+function fixXhtml(text) {
+	text = stripImgDimensions(renameRefs(unwrapSvgImages(text)));
+	if (text.includes("</head>") && !text.includes("<style type=\"text/css\">img,svg{max-width:100%;height:auto}body{overflow-wrap:break-word}table{max-width:100%;table-layout:fixed}pre,code{white-space:pre-wrap;word-wrap:break-word}*{box-sizing:border-box}</style>")) text = text.replace("</head>", `${DEFENSIVE_STYLE}</head>`);
+	return text;
+}
+/** JPEG media types for renamed images, no `svg` properties, and a cover meta pointing at the cover image. */
+function fixOpf(text) {
+	let out = text.replace(/<(?:\w+:)?item\b[^>]*>/g, (tag) => {
+		const href = /\bhref="([^"]*)"/.exec(tag)?.[1] ?? "";
+		if (/\.jpg$/i.test(href)) tag = tag.replace(/media-type="image\/(?:png|gif|webp|bmp)"/, "media-type=\"image/jpeg\"");
+		return tag.replace(/\sproperties="([^"]*)"/, (_m, properties) => {
+			const kept = properties.split(/\s+/).filter((p) => p && p !== "svg");
+			return kept.length ? ` properties="${kept.join(" ")}"` : "";
+		});
+	});
+	const coverId = findCoverId(out);
+	if (!coverId) return out;
+	const coverMeta = /<(?:\w+:)?meta\b[^>]*\bname="cover"[^>]*>/.exec(out);
+	if (coverMeta) {
+		if (/\bcontent="([^"]*)"/.exec(coverMeta[0])?.[1] !== coverId) out = out.replace(coverMeta[0], coverMeta[0].replace(/\bcontent="[^"]*"/, `content="${coverId}"`));
+	} else out = out.replace(/<\/((?:\w+:)?)metadata>/, (close, prefix) => `<${prefix}meta name="cover" content="${coverId}"/>${close}`);
+	return out;
+}
+/** The manifest id of the cover image: the `cover-image` item, or else an image with "cover" in its id or href. */
+function findCoverId(opf) {
+	const doc = parseXml(opf);
+	const images = (doc ? Array.from(doc.getElementsByTagName("*")).filter((el) => el.localName === "item") : []).filter((el) => (el.getAttribute("media-type") ?? "").startsWith("image/"));
+	return (images.find((el) => (el.getAttribute("properties") ?? "").split(/\s+/).includes("cover-image")) ?? images.find((el) => `${el.getAttribute("id")} ${el.getAttribute("href")}`.toLowerCase().includes("cover")))?.getAttribute("id") ?? void 0;
+}
+function extractIdentifier(opf) {
+	const uid = /<(?:\w+:)?package[^>]*unique-identifier=["']([^"']+)["']/i.exec(opf)?.[1];
+	if (uid) {
+		const escaped = uid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const value = new RegExp(`<dc:identifier[^>]*id=["']${escaped}["'][^>]*>([^<]+)</dc:identifier>`, "i").exec(opf)?.[1];
+		if (value) return value.trim();
+	}
+	return /<dc:identifier[^>]*>([^<]+)</i.exec(opf)?.[1]?.trim();
+}
+function syncNcxIdentifier(ncx, identifier) {
+	if (!identifier) return ncx;
+	const escaped = identifier.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+	return ncx.replace(/(<meta\s+name=["']dtb:uid["']\s+content=)["'][^"']*["']/i, (_m, pre) => `${pre}"${escaped}"`);
+}
+//#endregion
+export { DEFAULT_OPTIMIZE_OPTIONS, DEFENSIVE_STYLE, decodeText, extractIdentifier, fixOpf, fixXhtml, optimizeEpub, renameRefs, stripImgDimensions, syncNcxIdentifier, unwrapSvgImages };