reamkit 1.34.0 → 1.35.0

package/dist/esm/pdf-reader/text.js

@@ -34,7 +34,7 @@ function extractPageText(file, page, painted) {
 	};
 	const links = collectLinks(file, page);
 	const marks = collectTextMarkup(file, page);
-	const shown = withAccentsComposed(withoutRestrikes(runs));
+	const shown = withCyrillicSchwa(withAccentsComposed(withoutRestrikes(runs)));
 	if (links.length === 0 && marks.length === 0) return shown;
 	return shown.flatMap((run) => {
 		const link = links.find((l) => inRect(run.x, run.y, l.rect));
@@ -217,6 +217,70 @@ function withAccentsComposed(runs) {
 	return out;
 }
 /**
+* The Latin schwa a page wrote for the Cyrillic one, read as the Cyrillic.
+*
+* Arial, Times New Roman and Courier New draw ә (U+04D9) with the glyph of the
+* Latin schwa ə (U+0259), Ә with that of Ə, and a writer that names a glyph
+* after the first character reaching it says Latin: Word, Excel and PowerPoint
+* for Mac export every ә of a Kazakh, Tatar, Bashkir or Azerbaijani document
+* set in those faces as ə (probes of 2026-11-06), and Ream itself did until
+* it named each glyph after the letter it drew. Read as written, "және" is a
+* Cyrillic word with a Latin letter in it, which no language spells.
+*
+* A schwa is read as Cyrillic where its word's other letters are Cyrillic and
+* none Latin, and a word that is nothing but schwas (an alphabet's "Әә") where
+* its line's letters are: Cyrillic, at least three of them, and no Latin besides.
+* An Azerbaijani word in the Latin alphabet — "Azərbaycan" — is left as it is.
+*
+* @param runs The page's runs.
+* @returns The runs, each schwa among Cyrillic letters made Cyrillic.
+*/
+function withCyrillicSchwa(runs) {
+	if (!runs.some((r) => /[\u0259\u018f]/u.test(r.text))) return [...runs];
+	const out = [...runs];
+	let from = 0;
+	for (let i = 1; i <= runs.length; i++) {
+		const prev = runs[i - 1];
+		const run = runs[i];
+		if (run && continuesLine(prev, run)) continue;
+		if (runs.slice(from, i).some((r) => /[\u0259\u018f]/u.test(r.text))) {
+			const texts = runs.slice(from, i).map((r) => r.text);
+			const line = cyrillicSchwas(texts.join(""));
+			let at = 0;
+			texts.forEach((t, k) => {
+				const mine = line.slice(at, at + t.length);
+				at += t.length;
+				if (mine !== t) out[from + k] = {
+					...runs[from + k],
+					text: mine
+				};
+			});
+		}
+		from = i;
+	}
+	return out;
+}
+/** Whether one run takes up where another left off, on its baseline. */
+function continuesLine(a, b) {
+	if (a.angleDeg !== void 0 || b.angleDeg !== void 0) return false;
+	const size = b.fontSizePt || a.fontSizePt || 10;
+	return Math.abs(a.y - b.y) < size * .3 && Math.abs(b.x - a.endX) < size * .3;
+}
+/** A line's schwas among Cyrillic letters, made Cyrillic (see {@link withCyrillicSchwa}). */
+function cyrillicSchwas(line) {
+	const letters = [...line].filter((ch) => /\p{L}/u.test(ch));
+	const cyrillic = letters.filter((ch) => /\p{Script=Cyrillic}/u.test(ch)).length;
+	const otherLatin = letters.some((ch) => /\p{Script=Latin}/u.test(ch) && !SCHWA.has(ch));
+	const lineIsCyrillic = cyrillic >= 3 && !otherLatin;
+	return line.replace(/[\p{L}\p{M}]+/gu, (word) => {
+		if (!/[\u0259\u018f]/u.test(word)) return word;
+		const rest = [...word].filter((ch) => !SCHWA.has(ch) && /\p{L}/u.test(ch));
+		return (rest.length > 0 ? rest.some((ch) => /\p{Script=Cyrillic}/u.test(ch)) && !rest.some((ch) => /\p{Script=Latin}/u.test(ch)) : lineIsCyrillic) ? word.replace(/[\u0259\u018f]/gu, (ch) => SCHWA.get(ch)) : word;
+	});
+}
+/** The Latin schwas, and the Cyrillic letters a page drawn in Cyrillic meant by them. */
+var SCHWA = /* @__PURE__ */ new Map([["ə", "ә"], ["Ə", "Ә"]]);
+/**
 * Whether an accent stands over the first letter of a run (the pen taken back
 * under it) or over the last (the pen taken back to strike it): on one
 * baseline, give or take the lift an accent over a capital takes, and

package/dist/esm/word/docx-to-pdf.js

@@ -1,4 +1,4 @@
-import { fetchFontSet, resolveFamilyKey } from "../core/fonts/remote-fonts.js";
+import { companionOf, fetchFontSet, resolveFamilyKey } from "../core/fonts/remote-fonts.js";
 import { FontRegistry } from "../core/font/font-registry.js";
 import "../core/font/index.js";
 import { signPdf } from "../pdf/signature.js";
@@ -137,7 +137,8 @@ async function buildUnsignedDocxPdf(docx, options) {
 async function resolveDocxAutoFonts(docx, options = {}) {
 	const fetchOpt = options.fontFetch ? { fetch: options.fontFetch } : {};
 	const keys = options.fontFamily ? /* @__PURE__ */ new Set([resolveFamilyKey(options.fontFamily)]) : detectDocxFamilyKeys(docx);
-	if (keys.size <= 1) {
+	const companions = detectDocxCompanions(docx, keys);
+	if (keys.size <= 1 && companions.size === 0) {
 		const family = keys.values().next().value;
 		return { fonts: await fetchFontSet({
 			...family ? { family } : {},
@@ -154,10 +155,52 @@ async function resolveDocxAutoFonts(docx, options = {}) {
 		registriesByFamily.set(key, FontRegistry.fromBytes(bytes));
 		if (key === "arimo" || !baseBytes) baseBytes = bytes;
 	}
+	for (const family of companions) {
+		if (registriesByFamily.has(family)) continue;
+		try {
+			registriesByFamily.set(family, FontRegistry.fromBytes(await fetchFontSet({
+				family,
+				...fetchOpt
+			})));
+		} catch {}
+	}
 	return {
 		fonts: baseBytes,
 		registriesByFamily
 	};
 }
+/**
+* The companions a `.docx`'s substitutes need (see `companionOf`): those whose
+* blocks the document's text holds a character of — a Cambria document in
+* Russian needs Noto Serif for its letters, one in English does not.
+*
+* @param docx     The `.docx` bytes.
+* @param families The substitute families it names.
+* @returns The companion families to fetch.
+*/
+function detectDocxCompanions(docx, families) {
+	const wanted = [...families].flatMap((key) => {
+		const companion = companionOf(key);
+		return companion ? [companion] : [];
+	});
+	const out = /* @__PURE__ */ new Set();
+	if (wanted.length === 0) return out;
+	let xml;
+	try {
+		const main = OpcPackage.open(docx).getPart(MAIN_DOCUMENT_PART);
+		if (!main) return out;
+		xml = new TextDecoder("utf-8").decode(main);
+	} catch {
+		return out;
+	}
+	for (const c of wanted) for (const ch of xml) {
+		const cp = ch.codePointAt(0);
+		if (c.ranges.some(([lo, hi]) => cp >= lo && cp <= hi)) {
+			out.add(c.family);
+			break;
+		}
+	}
+	return out;
+}
 //#endregion
 export { convertDocxToPdf, convertDocxToPdfSync, detectDocxFamilyKeys, resolveDocxAutoFonts };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reamkit",
-  "version": "1.34.0",
+  "version": "1.35.0",
   "description": "Ream — convert DOCX, XLSX, PPTX, PDF and legacy DOC, XLS and PPT to PDF, SVG, HTML, Markdown, DOCX and XLSX, built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
   "license": "MIT",
   "author": "Alexandr Krassavin <info@reamkit.dev>",
@@ -113,5 +113,10 @@
   },
   "engines": {
     "node": ">=20"
+  },
+  "allowScripts": {
+    "esbuild": false,
+    "unrs-resolver": false,
+    "fsevents": false
   }
 }