reamkit 1.30.0 → 1.32.0

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

@@ -22,8 +22,6 @@ var UNDERSTOOD_NS = new Set([
 ]);
 function parseFloatAnchor(anchor) {
 	if (!poIs(anchor, "wp:anchor")) return void 0;
-	const behindRaw = poAttr(anchor, "behindDoc");
-	const behind = behindRaw === "1" || behindRaw === "true";
 	let wrap = "none";
 	let wrapSide;
 	for (const child of poChildren(anchor)) {
@@ -35,6 +33,8 @@ function parseFloatAnchor(anchor) {
 		const side = poAttr(child, "wrapText");
 		wrapSide = side === "left" || side === "right" || side === "largest" ? side : "bothSides";
 	}
+	const behindRaw = poAttr(anchor, "behindDoc");
+	const behind = (behindRaw === "1" || behindRaw === "true") && wrap === "none";
 	const zOrder = poIntAttr(anchor, "relativeHeight");
 	const posH = parseAnchorPos(anchor, "wp:positionH", [
 		"margin",
@@ -163,18 +163,20 @@ function parseAnchorPos(anchor, tag, allowed) {
 * ECMA-376 Part 3 (Markup Compatibility) — resolve an `<mc:AlternateContent>` to
 * the children of the first `<mc:Choice>` whose `Requires` lists only namespaces
 * we understand, else the `<mc:Fallback>` children, else nothing. (`Requires`
-* holds space-separated namespace prefixes as declared in the document.)
+* holds space-separated namespace prefixes as declared in the document.) The
+* elements are known by their local names, whatever prefix the producer bound
+* the namespace to: Word 2008 for Mac wrote `ve:`.
 *
 * @param altContent The `mc:AlternateContent` node.
 * @returns The chosen branch's children.
 */
 function resolveMc(altContent) {
 	for (const choice of poChildren(altContent)) {
-		if (!poIs(choice, "mc:Choice")) continue;
+		if (!poIsLocal(choice, "Choice")) continue;
 		const requires = (poAttr(choice, "Requires") ?? "").split(/\s+/).filter(Boolean);
 		if (requires.length > 0 && requires.every((r) => UNDERSTOOD_NS.has(r))) return poChildren(choice);
 	}
-	const fallback = poChildren(altContent).find((c) => poIs(c, "mc:Fallback"));
+	const fallback = poChildren(altContent).find((c) => poIsLocal(c, "Fallback"));
 	return fallback ? poChildren(fallback) : [];
 }
 /**
@@ -188,22 +190,55 @@ function resolveMc(altContent) {
 */
 function expandMcChildren(children) {
 	const out = [];
-	for (const c of children) if (poIs(c, "mc:AlternateContent")) out.push(...resolveMc(c));
+	for (const c of children) if (poIsLocal(c, "AlternateContent")) out.push(...resolveMc(c));
 	else out.push(c);
 	return out;
 }
 /**
+* The node with every markup-compatibility block beneath it resolved (see
+* {@link resolveMc}), so that a search through its descendants finds only
+* the content a reader like this one is to take. Bug51170.docx's header offers
+* its logo twice — a PDF for Word for Mac as the Choice, a PNG as the Fallback
+* — and the first `a:blip` in document order was the PDF, which is not a
+* picture a page can show: the logo was left out.
+*
+* @param node The node to resolve.
+* @returns The node itself where nothing beneath it needed resolving.
+*/
+function resolveMcTree(node) {
+	const tag = poTag(node);
+	const children = poChildren(node);
+	if (tag === void 0 || children.length === 0) return node;
+	let changed = false;
+	const resolved = [];
+	for (const child of children) {
+		if (poIsLocal(child, "AlternateContent")) {
+			changed = true;
+			for (const chosen of resolveMc(child)) resolved.push(resolveMcTree(chosen));
+			continue;
+		}
+		const inner = resolveMcTree(child);
+		if (inner !== child) changed = true;
+		resolved.push(inner);
+	}
+	return changed ? {
+		...node,
+		[tag]: resolved
+	} : node;
+}
+/**
 * Parse a `<w:drawing>` (ECMA-376 Part 1 §20) into a {@link DrawingContent}. The
 * `a:graphicData` `@uri` selects the branch: a `wps:wsp` shape, a chart, a
 * SmartArt diagram, or — falling through — an embedded picture from
 * `a:blip @r:embed`.
 *
-* @param drawing      The `w:drawing` node.
+* @param drawingNode  The `w:drawing` node.
 * @param resolveColor Resolver for theme/scheme colours used by shape fills/lines.
 * @param parseBody    Optional body parser for a shape's text box (omitted ⇒ no text).
 * @returns The parsed content, or `null` when no anchor / recognizable graphic is found.
 */
-function parseDrawing(drawing, resolveColor, parseBody, resolveImage, resolveChartPart, themeLineWidths, themeStyles, parseDrawingText) {
+function parseDrawing(drawingNode, resolveColor, parseBody, resolveImage, resolveChartPart, themeLineWidths, themeStyles, parseDrawingText) {
+	const drawing = resolveMcTree(drawingNode);
 	const anchor = poChildren(drawing).find((c) => poIs(c, "wp:inline")) ?? poChildren(drawing).find((c) => poIs(c, "wp:anchor"));
 	if (!anchor) return null;
 	const extent = poFindDescendant(anchor, "wp:extent");
@@ -1083,6 +1118,12 @@ function vmlFloat(style, zIndexAttr, shape) {
 	const zIndex = prop("z-index") ?? zIndexAttr;
 	return {
 		wrap: vmlWrap(shape),
+		wrapDist: {
+			topPt: pt(prop("mso-wrap-distance-top") ?? 0),
+			bottomPt: pt(prop("mso-wrap-distance-bottom") ?? 0),
+			leftPt: pt(prop("mso-wrap-distance-left") ?? 9),
+			rightPt: pt(prop("mso-wrap-distance-right") ?? 9)
+		},
 		...poAttrLocal(shape, "allowincell") === "f" ? { inCell: false } : {},
 		...zIndex !== void 0 && zIndex < 0 ? { behind: true } : {},
 		...zIndex !== void 0 ? { zOrder: Math.abs(zIndex) } : {},

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

@@ -0,0 +1,30 @@
+import { FaceFamily, FaceOutlines } from '../core/ir/flow.js';
+import { Loss } from '../core/ir/index.js';
+import { OpcPart, Relationship } from '../core/opc/index.js';
+/** §17.8.1 — the content type of an obfuscated embedded font. */
+export declare const OBFUSCATED_FONT_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.obfuscatedFont";
+/** The faces written into a package, and how the font table reaches them. */
+export interface EmbeddedFaces {
+    /** Family → the `w:embed*` elements its `w:font` carries (§17.8.3.3–6). */
+    readonly elements: ReadonlyMap<string, string>;
+    /** The obfuscated font parts, under `word/fonts/`. */
+    readonly parts: ReadonlyArray<OpcPart>;
+    /** The font table's relationships to them. */
+    readonly relationships: ReadonlyArray<Relationship>;
+}
+/**
+ * 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.
+ */
+export declare function embedFaces(used: Iterable<string>, outlines: ReadonlyMap<string, FaceOutlines>, families: ReadonlyMap<string, FaceFamily>, losses: Array<Loss>): EmbeddedFaces;

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.32.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",
@@ -79,6 +84,10 @@
     "corpus:pixel": "tsx scripts/corpus/pixel-scout.ts",
     "stand": "tsx stand/serve.ts",
     "stand:build": "tsx stand/build.ts",
+    "stand:html": "tsx stand/serve.ts html",
+    "stand:html:build": "tsx stand/html-build.ts",
+    "stand:svg": "tsx stand/serve.ts svg",
+    "stand:svg:build": "tsx stand/svg-build.ts",
     "typecheck:dist": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {