reamkit 1.30.0 → 1.31.0

package/dist/esm/word/font-embed.js

@@ -0,0 +1,173 @@
+import { buildTrueType, editableEmbedding } from "../core/font/ttf-build.js";
+import { FEATURES } from "../core/ir/features.js";
+import { obfuscateEmbeddedFont } from "./font-table.js";
+import { md5 } from "../core/crypto/primitives.js";
+//#region src/word/font-embed.ts
+/** §17.8.1 — the content type of an obfuscated embedded font. */
+var OBFUSCATED_FONT_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.obfuscatedFont";
+var REL_FONT = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font";
+/** §17.8.3 — the four faces a family may embed, in the order CT_Font lists them. */
+var SLOTS = [
+	"Regular",
+	"Bold",
+	"Italic",
+	"BoldItalic"
+];
+/**
+* Build the embedded fonts for the faces the runs name (§17.8.1).
+*
+* The faces are gathered by family and by slot — the style each face IS. Two
+* faces in one slot (a SemiBold and a Bold, both written bold) become one font:
+* the face with the most characters, and the other's characters it lacks.
+*
+* A face its licence keeps out is reported, not written.
+*
+* @param used     The run font names the document's runs carry.
+* @param outlines Run font name → the face's outlines.
+* @param families Run font name → the family a word processor knows it by.
+* @param losses   Appended to for every face left out.
+* @returns The fonts to write and the font table's references to them.
+*/
+function embedFaces(used, outlines, families, losses) {
+	const bySlot = /* @__PURE__ */ new Map();
+	for (const name of new Set(used)) {
+		const face = outlines.get(name);
+		const family = families.get(name)?.family;
+		if (!face || family === void 0) continue;
+		if (!editableEmbedding(face.fsType)) {
+			losses.push({
+				severity: "degraded",
+				feature: FEATURES.fontsEmbedding,
+				detail: `font ${face.postScriptName} not embedded: its licence (OS/2 fsType ${face.fsType}) does not allow it in an editable document`
+			});
+			continue;
+		}
+		const slot = face.bold ? face.italic ? "BoldItalic" : "Bold" : face.italic ? "Italic" : "Regular";
+		let slots = bySlot.get(family);
+		if (!slots) bySlot.set(family, slots = /* @__PURE__ */ new Map());
+		slots.set(slot, [...slots.get(slot) ?? [], face]);
+	}
+	const elements = /* @__PURE__ */ new Map();
+	const parts = [];
+	const relationships = [];
+	for (const family of [...bySlot.keys()].sort()) {
+		const slots = bySlot.get(family);
+		for (const slot of SLOTS) {
+			const faces = [...slots.get(slot) ?? []].sort((a, b) => b.glyphs.size - a.glyphs.size);
+			const first = faces[0];
+			if (!first) continue;
+			const glyphs = new Map(first.glyphs);
+			const kerning = new Map(first.kerning);
+			const ligatures = new Map(first.ligatures);
+			for (const other of faces.slice(1)) {
+				for (const [char, glyph] of other.glyphs) if (!glyphs.has(char)) glyphs.set(char, glyph);
+				for (const [pair, value] of other.kerning ?? []) if (!kerning.has(pair)) kerning.set(pair, value);
+				for (const [letters, glyph] of other.ligatures ?? []) if (!ligatures.has(letters)) ligatures.set(letters, glyph);
+			}
+			const built = builtGlyphs(glyphs);
+			if (built.length + ligatures.size > 8e3) {
+				losses.push({
+					severity: "degraded",
+					feature: FEATURES.fontsEmbedding,
+					detail: `font ${first.postScriptName} not embedded: ${built.length + ligatures.size} glyphs is more than an embedded subset holds`
+				});
+				continue;
+			}
+			const program = buildTrueType({
+				family,
+				bold: slot === "Bold" || slot === "BoldItalic",
+				italic: slot === "Italic" || slot === "BoldItalic",
+				postScriptName: first.postScriptName,
+				glyphs: built,
+				ascent: first.ascent,
+				descent: first.descent,
+				...first.capHeight !== void 0 ? { capHeight: first.capHeight } : {},
+				...first.xHeight !== void 0 ? { xHeight: first.xHeight } : {},
+				italicAngle: first.italicAngle,
+				fixedPitch: first.fixedPitch,
+				fsType: statedFsType(first.fsType),
+				kerning: kernPairs(kerning),
+				ligatures: [...ligatures].map(([letters, glyph]) => ({
+					codePoints: [...letters].map((c) => c.codePointAt(0)),
+					outline: glyph.outline,
+					advance: glyph.advance
+				}))
+			});
+			const fontKey = fontKeyOf(program);
+			const index = parts.length + 1;
+			const target = `fonts/font${index}.odttf`;
+			const id = `rId${index}`;
+			parts.push({
+				path: `word/${target}`,
+				data: obfuscateEmbeddedFont(program, fontKey),
+				contentType: OBFUSCATED_FONT_CONTENT_TYPE
+			});
+			relationships.push({
+				id,
+				type: REL_FONT,
+				target,
+				targetMode: "Internal"
+			});
+			elements.set(family, `${elements.get(family) ?? ""}<w:embed${slot} r:id="${id}" w:fontKey="${fontKey}" w:subsetted="1"/>`);
+		}
+	}
+	return {
+		elements,
+		parts,
+		relationships
+	};
+}
+/**
+* A face's characters as the glyphs of a font: characters that share one glyph
+* (the space and the no-break space) select the same one, and the glyphs stand
+* in the order of their first character.
+*/
+function builtGlyphs(glyphs) {
+	const byGlyph = /* @__PURE__ */ new Map();
+	for (const [char, glyph] of glyphs) {
+		const cp = char.codePointAt(0);
+		if (cp === void 0) continue;
+		byGlyph.set(glyph, [...byGlyph.get(glyph) ?? [], cp]);
+	}
+	return [...byGlyph].map(([glyph, codePoints]) => ({
+		codePoints: codePoints.sort((a, b) => a - b),
+		outline: glyph.outline,
+		advance: glyph.advance
+	})).sort((a, b) => a.codePoints[0] - b.codePoints[0]);
+}
+/** The face's kerning pairs as the font states them: by code point, left then right. */
+function kernPairs(kerning) {
+	const out = [];
+	for (const [pair, value] of kerning) {
+		const [left, right] = [...pair].map((c) => c.codePointAt(0));
+		if (left !== void 0 && right !== void 0) out.push({
+			left,
+			right,
+			value
+		});
+	}
+	return out;
+}
+/**
+* The `fsType` the built font states: the program's own, less the bits the
+* format reserves; Editable where the program stated none — which is the use
+* the font is put to here, and no more than that.
+*/
+function statedFsType(fsType) {
+	if (fsType === void 0) return EDITABLE_EMBEDDING;
+	return fsType & DEFINED_FS_TYPE_BITS;
+}
+/** OS/2 `fsType` — Editable embedding, and every bit the format defines. */
+var EDITABLE_EMBEDDING = 8;
+var DEFINED_FS_TYPE_BITS = 782;
+/**
+* §17.8.1 — the GUID a font is obfuscated with, drawn from the font's own bytes
+* so the same document always writes the same package.
+*/
+function fontKeyOf(program) {
+	const hex = [...md5(program)].map((b) => b.toString(16).padStart(2, "0").toUpperCase());
+	const group = (from, to) => hex.slice(from, to).join("");
+	return `{${group(0, 4)}-${group(4, 6)}-${group(6, 8)}-${group(8, 10)}-${group(10, 16)}}`;
+}
+//#endregion
+export { OBFUSCATED_FONT_CONTENT_TYPE, embedFaces };

package/dist/esm/word/font-table.d.ts

@@ -18,6 +18,16 @@ interface FontTableEntry {
  * @returns The de-obfuscated bytes, or `data` unchanged when `fontKey` is not a GUID.
  */
 export declare function deobfuscateEmbeddedFont(data: Uint8Array, fontKey: string): Uint8Array;
+/**
+ * §17.8.1 — obfuscate a font for embedding. The obfuscation is an XOR of the
+ * first 32 bytes with the `fontKey` GUID's bytes in reverse order, so it is its
+ * own inverse: this is {@link deobfuscateEmbeddedFont} run on a plain font.
+ *
+ * @param data    The plain sfnt bytes.
+ * @param fontKey The GUID the font table states as its `w:fontKey`.
+ * @returns The bytes to store as the `.odttf` part.
+ */
+export declare function obfuscateEmbeddedFont(data: Uint8Array, fontKey: string): Uint8Array;
 /**
  * Parse `word/fontTable.xml` for its embedded-font references (§17.8). Returns
  * one `FontTableEntry` per `w:font` that carries at least one `w:embed*` child,

package/dist/esm/word/font-table.js

@@ -28,6 +28,18 @@ function deobfuscateEmbeddedFont(data, fontKey) {
 	return out;
 }
 /**
+* §17.8.1 — obfuscate a font for embedding. The obfuscation is an XOR of the
+* first 32 bytes with the `fontKey` GUID's bytes in reverse order, so it is its
+* own inverse: this is {@link deobfuscateEmbeddedFont} run on a plain font.
+*
+* @param data    The plain sfnt bytes.
+* @param fontKey The GUID the font table states as its `w:fontKey`.
+* @returns The bytes to store as the `.odttf` part.
+*/
+function obfuscateEmbeddedFont(data, fontKey) {
+	return deobfuscateEmbeddedFont(data, fontKey);
+}
+/**
 * Parse `word/fontTable.xml` for its embedded-font references (§17.8). Returns
 * one `FontTableEntry` per `w:font` that carries at least one `w:embed*` child,
 * each naming the relationship id + `w:fontKey` for a Regular/Bold/Italic/
@@ -103,4 +115,4 @@ function loadEmbeddedFonts(pkg) {
 	return out;
 }
 //#endregion
-export { deobfuscateEmbeddedFont, loadEmbeddedFonts, parseFontTable };
+export { deobfuscateEmbeddedFont, loadEmbeddedFonts, obfuscateEmbeddedFont, parseFontTable };

package/dist/esm/word/index.js

@@ -1,9 +1,9 @@
 import "./run-properties.js";
 import "./paragraph-properties.js";
 import "./table-parser.js";
+import "./numbering-parser.js";
 import "./document-parser.js";
 import "./text-extractor.js";
 import "./styles-parser.js";
 import "./font-table.js";
-import "./numbering-parser.js";
 import "./settings-parser.js";

package/dist/esm/word/numbering-parser.d.ts

@@ -1,6 +1,8 @@
-import { Numbering } from '../core/document-model/index.js';
+import { Numbering, NumberingFormat } from '../core/document-model/index.js';
 import { ResourceId } from '../core/ir/index.js';
 import { ThemeFonts } from '../core/drawingml/theme-parser.js';
+/** §17.18.59 ST_NumberFormat — the formats this reader knows by name. */
+export declare const FORMATS: ReadonlySet<NumberingFormat>;
 /** The empty {@link Numbering} returned when a document has no `numbering.xml`. */
 export declare const EMPTY_NUMBERING: Numbering;
 /**

package/dist/esm/word/numbering-parser.js

@@ -14,6 +14,7 @@ var parser = new XMLParser({
 	parseTagValue: false,
 	trimValues: false
 });
+/** §17.18.59 ST_NumberFormat — the formats this reader knows by name. */
 var FORMATS = new Set([
 	"decimal",
 	"decimalZero",
@@ -184,4 +185,4 @@ function getValVal(node) {
 	return typeof v === "string" ? v : void 0;
 }
 //#endregion
-export { EMPTY_NUMBERING, parseNumbering };
+export { EMPTY_NUMBERING, FORMATS, parseNumbering };

package/dist/esm/word/paragraph-properties.d.ts

@@ -1,10 +1,11 @@
 import { ParagraphProperties } from '../core/document-model/index.js';
 import { ThemeFonts } from '../core/drawingml/theme-parser.js';
 /**
- * §17.3.1.1/§17.3.1.3 — the gap `w:*Autospacing` asks the consumer for. Word's
- * own automatic value is HTML's 14pt, and only a document old enough to state
- * no `w:compatSetting compatibilityMode` still gets it: from Word 2007 on the
- * automatic value is nothing at all, which is what both references leave.
+ * §17.3.1.1/§17.3.1.3 — the gap `w:*Autospacing` asks the consumer for:
+ * HTML's 14pt, in every compatibility mode. Word for Mac stands two such
+ * paragraphs 14.02pt apart in modes 14, 15 and none alike; LibreOffice leaves
+ * nothing for a document that states a mode, which is where the earlier
+ * reading of "nothing from Word 2007 on" came from.
  */
 export declare const HTML_AUTO_SPACING_PT = 14;
 /**
@@ -16,8 +17,8 @@ export declare const HTML_AUTO_SPACING_PT = 14;
  * @param pPr The `w:pPr` element in flat (fast-xml-parser) shape, or anything
  *   non-element (yielding an empty result).
  * @param autoSpacingPt What `w:beforeAutospacing`/`w:afterAutospacing` resolve
- *   to — {@link HTML_AUTO_SPACING_PT} for a document that states no
- *   compatibility mode, and 0 (the default) for every Word 2007-or-later one.
+ *   to — {@link HTML_AUTO_SPACING_PT} for a Word document, 0 (the default)
+ *   where the caller has no automatic spacing to give.
  * @returns The extracted properties; an empty object when `pPr` is absent.
  */
 export declare function parseParagraphProperties(pPr: unknown, autoSpacingPt?: number, themeFonts?: ThemeFonts): ParagraphProperties;

package/dist/esm/word/paragraph-properties.js

@@ -100,8 +100,8 @@ function parseFramePr(node) {
 * @param pPr The `w:pPr` element in flat (fast-xml-parser) shape, or anything
 *   non-element (yielding an empty result).
 * @param autoSpacingPt What `w:beforeAutospacing`/`w:afterAutospacing` resolve
-*   to — {@link HTML_AUTO_SPACING_PT} for a document that states no
-*   compatibility mode, and 0 (the default) for every Word 2007-or-later one.
+*   to — {@link HTML_AUTO_SPACING_PT} for a Word document, 0 (the default)
+*   where the caller has no automatic spacing to give.
 * @returns The extracted properties; an empty object when `pPr` is absent.
 */
 function parseParagraphProperties(pPr, autoSpacingPt = 0, themeFonts) {
@@ -172,6 +172,18 @@ function parseParagraphProperties(pPr, autoSpacingPt = 0, themeFonts) {
 		const v = parseToggle(el["w:pageBreakBefore"]);
 		if (v !== void 0) out.pageBreakBefore = v;
 	}
+	if ("w:keepNext" in el) {
+		const v = parseToggle(el["w:keepNext"]);
+		if (v !== void 0) out.keepNext = v;
+	}
+	if ("w:keepLines" in el) {
+		const v = parseToggle(el["w:keepLines"]);
+		if (v !== void 0) out.keepLines = v;
+	}
+	if ("w:widowControl" in el) {
+		const v = parseToggle(el["w:widowControl"]);
+		if (v !== void 0) out.widowControl = v;
+	}
 	if ("w:bidi" in el) {
 		const v = parseToggle(el["w:bidi"]);
 		if (v !== void 0) out.bidi = v;

package/dist/esm/word/run-properties.js

@@ -20,6 +20,24 @@ var VERTICAL_ALIGNS = new Set([
 	"superscript",
 	"subscript"
 ]);
+var LIGATURES = new Set([
+	"none",
+	"standard",
+	"contextual",
+	"historical",
+	"discretional",
+	"standardContextual",
+	"standardHistorical",
+	"contextualHistorical",
+	"standardDiscretional",
+	"contextualDiscretional",
+	"historicalDiscretional",
+	"standardContextualHistorical",
+	"standardContextualDiscretional",
+	"standardHistoricalDiscretional",
+	"contextualHistoricalDiscretional",
+	"all"
+]);
 var HIGHLIGHT_COLORS = new Map([
 	["black", "000000"],
 	["blue", "0000FF"],
@@ -110,6 +128,14 @@ function parseRunProperties(rPr, themeFonts) {
 		const n = v === void 0 ? NaN : Number(v);
 		if (Number.isFinite(n) && n !== 0) out.letterSpacingPt = twipsToPt(n);
 	}
+	if ("w:kern" in el) {
+		const n = Number(getVal(el["w:kern"]));
+		if (Number.isFinite(n) && n >= 0) out.kerningMinPt = halfPtToPt(n);
+	}
+	if ("w14:ligatures" in el) {
+		const v = asElement(el["w14:ligatures"])?.["@_w14:val"];
+		if (typeof v === "string" && LIGATURES.has(v)) out.ligatures = v;
+	}
 	if ("w:shd" in el) {
 		const shd = el["w:shd"];
 		const hex = shadingFillHex(getVal(shd), getAttr(shd, "color"), getAttr(shd, "fill"));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reamkit",
-  "version": "1.30.0",
-  "description": "Ream — convert DOCX, XLSX, PPTX and PDF to PDF, SVG, HTML, DOCX and XLSX, built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
+  "version": "1.31.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": "Alex Krassavin <info@reamkit.dev>",
   "repository": {
@@ -48,7 +48,12 @@
     "word",
     "excel",
     "powerpoint",
-    "converter"
+    "converter",
+    "doc",
+    "xls",
+    "ppt",
+    "markdown",
+    "pdf-to-docx"
   ],
   "scripts": {
     "build": "vite build",