reamkit 1.24.0 → 1.25.1

package/dist/esm/word/docx-writer.js

@@ -447,19 +447,49 @@ function shapeDrawingXml(shape, losses, state, scope) {
 function xfrmXml(t, cx, cy) {
 	return `<a:xfrm${t?.rotation60k !== void 0 ? ` rot="${t.rotation60k}"` : ""}${t?.flipH ? " flipH=\"1\"" : ""}${t?.flipV ? " flipV=\"1\"" : ""}><a:off x="0" y="0"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm>`;
 }
+/**
+* The factor that carries a path into whole units, and the space it lands in.
+*
+* §20.1.10.16 — ST_Coordinate is a LONG: a path states its geometry in whole
+* units, and a fractional one is not a value the attribute admits. Word does
+* not round it, and does not ignore the shape: it refuses the document, saying
+* only that it "experienced an error trying to open the file".
+*
+* A path space is arbitrary — `a:path w`/`h` declare the coordinate system the
+* shape's extent is mapped onto — so a path that does not land on whole units
+* is restated in a finer space rather than rounded where it stands. A path read
+* off a PDF is in points, and a point split ten thousand ways is finer than any
+* renderer draws. The factor is bounded so the space stays far inside the
+* coordinate range whatever the path's own size, and a path already on whole
+* units is left exactly as it is.
+*/
+var PATH_SPACE = 1e7;
+function pathScale(g) {
+	const values = [g.pathWidth, g.pathHeight];
+	for (const c of g.commands) if (c.cmd === "move" || c.cmd === "line") values.push(c.x, c.y);
+	else if (c.cmd === "cubic") values.push(c.x1, c.y1, c.x2, c.y2, c.x, c.y);
+	else if (c.cmd === "quad") values.push(c.x1, c.y1, c.x, c.y);
+	else if (c.cmd === "arc") values.push(c.wR, c.hR);
+	if (values.every((v) => Number.isInteger(v))) return 1;
+	const span = Math.max(...values.map((v) => Number.isFinite(v) ? Math.abs(v) : 0), 1);
+	return Math.max(1, Math.floor(PATH_SPACE / span));
+}
 function geomXml(g) {
 	if (g.kind === "custom" && g.custom) {
+		const k = pathScale(g.custom);
+		const c1 = (v) => Number.isFinite(v) ? Math.round(v * k) : 0;
 		const cmds = g.custom.commands.map((c) => {
 			switch (c.cmd) {
-				case "move": return `<a:moveTo><a:pt x="${c.x}" y="${c.y}"/></a:moveTo>`;
-				case "line": return `<a:lnTo><a:pt x="${c.x}" y="${c.y}"/></a:lnTo>`;
-				case "cubic": return `<a:cubicBezTo><a:pt x="${c.x1}" y="${c.y1}"/><a:pt x="${c.x2}" y="${c.y2}"/><a:pt x="${c.x}" y="${c.y}"/></a:cubicBezTo>`;
-				case "quad": return `<a:quadBezTo><a:pt x="${c.x1}" y="${c.y1}"/><a:pt x="${c.x}" y="${c.y}"/></a:quadBezTo>`;
-				case "arc": return `<a:arcTo wR="${c.wR}" hR="${c.hR}" stAng="${c.stAng}" swAng="${c.swAng}"/>`;
+				case "move": return `<a:moveTo><a:pt x="${c1(c.x)}" y="${c1(c.y)}"/></a:moveTo>`;
+				case "line": return `<a:lnTo><a:pt x="${c1(c.x)}" y="${c1(c.y)}"/></a:lnTo>`;
+				case "cubic": return `<a:cubicBezTo><a:pt x="${c1(c.x1)}" y="${c1(c.y1)}"/><a:pt x="${c1(c.x2)}" y="${c1(c.y2)}"/><a:pt x="${c1(c.x)}" y="${c1(c.y)}"/></a:cubicBezTo>`;
+				case "quad": return `<a:quadBezTo><a:pt x="${c1(c.x1)}" y="${c1(c.y1)}"/><a:pt x="${c1(c.x)}" y="${c1(c.y)}"/></a:quadBezTo>`;
+				case "arc": return `<a:arcTo wR="${c1(c.wR)}" hR="${c1(c.hR)}" stAng="${Math.round(c.stAng)}" swAng="${Math.round(c.swAng)}"/>`;
 				case "close": return "<a:close/>";
 			}
 		}).join("");
-		const { pathWidth: w, pathHeight: h } = g.custom;
+		const w = c1(g.custom.pathWidth);
+		const h = c1(g.custom.pathHeight);
 		return `<a:custGeom><a:avLst/><a:gdLst/><a:rect l="0" t="0" r="${w}" b="${h}"/><a:pathLst><a:path w="${w}" h="${h}">${cmds}</a:path></a:pathLst></a:custGeom>`;
 	}
 	const gds = g.adjust && g.adjust.size > 0 ? [...g.adjust].map(([n, v]) => `<a:gd name="${escapeAttr(n)}" fmla="val ${v}"/>`).join("") : "";
@@ -527,6 +557,16 @@ function tableXml(table, losses, state, scope) {
 	const rows = table.rows.map((row) => rowXml(row, losses, state, scope)).join("");
 	return `<w:tbl>${tblPrXml(table.properties)}<w:tblGrid>${grid}</w:tblGrid>${rows}</w:tbl>`;
 }
+/**
+* §17.4.60 — `w:tblPr`. CT_Tbl declares it `minOccurs="1"`: a table states its
+* properties even when it has none to state, and Word refuses to open a file
+* whose `w:tbl` opens straight into its grid. Nothing else in the wild writes
+* one without it — 5432 tables across the LibreOffice, Word and POI corpora,
+* every one of them with a `w:tblPr` — and it went unnoticed here because a
+* table read from a real document always carries SOMETHING (a width, a border,
+* an alignment). One reconstructed from a PDF's glyph positions carries none of
+* it, so `Ream.parse(pdf).convert('docx')` wrote a document Word turned away.
+*/
 function tblPrXml(p) {
 	const out = [];
 	if (p.widthType !== void 0) {
@@ -538,7 +578,7 @@ function tblPrXml(p) {
 	if (borders) out.push(borders);
 	const margins = cellMarginsXml("w:tblCellMar", p.defaultCellMargins);
 	if (margins) out.push(margins);
-	return out.length > 0 ? `<w:tblPr>${out.join("")}</w:tblPr>` : "";
+	return `<w:tblPr>${out.join("")}</w:tblPr>`;
 }
 function rowXml(row, losses, state, scope) {
 	const trPr = [];
@@ -681,25 +721,47 @@ function pPrBody(p) {
 	if (ind) out.push(ind);
 	const spacing = spacingXml(p);
 	if (spacing) out.push(spacing);
-	if (p.alignment !== DEFAULT_PARA.alignment) out.push(`<w:jc w:val="${p.alignment}"/>`);
+	if (JC.has(p.alignment) && p.alignment !== DEFAULT_PARA.alignment) out.push(`<w:jc w:val="${p.alignment}"/>`);
 	return out.join("");
 }
 function pPrWithSect(p, closingSectPr) {
 	const inner = pPrBody(p) + (closingSectPr ?? "");
 	return inner !== "" ? `<w:pPr>${inner}</w:pPr>` : "";
 }
+/**
+* Whether a measurement is one the file can state.
+*
+* A property that was COMPUTED rather than read can arrive `NaN` — an
+* `undefined` that went through arithmetic, a share of a width that was zero —
+* and `NaN` is not a value ST_SignedTwipsMeasure admits. Word does not ignore
+* the attribute: it refuses the whole document, with no indication of what it
+* objected to. `Ream.parse(pdf).convert('docx')` wrote 355 of them on one form.
+*
+* So a measurement is written only when there IS one, and a paragraph that
+* cannot say how it is indented says nothing and inherits, which is what an
+* absent attribute means (§17.3.1.12).
+*/
+var stated = (pt) => Number.isFinite(pt);
+/** §17.18.44 ST_Jc — the tokens the attribute admits, so nothing else is written. */
+var JC = new Set([
+	"left",
+	"right",
+	"center",
+	"both",
+	"distribute"
+]);
 function indXml(p) {
 	const attrs = [];
-	if (p.indentLeft !== DEFAULT_PARA.indentLeft) attrs.push(`w:left="${twips(p.indentLeft)}"`);
-	if (p.indentRight !== DEFAULT_PARA.indentRight) attrs.push(`w:right="${twips(p.indentRight)}"`);
-	if (p.indentFirstLine !== DEFAULT_PARA.indentFirstLine) if (p.indentFirstLine < 0) attrs.push(`w:hanging="${twips(-p.indentFirstLine)}"`);
+	if (stated(p.indentLeft) && p.indentLeft !== DEFAULT_PARA.indentLeft) attrs.push(`w:left="${twips(p.indentLeft)}"`);
+	if (stated(p.indentRight) && p.indentRight !== DEFAULT_PARA.indentRight) attrs.push(`w:right="${twips(p.indentRight)}"`);
+	if (stated(p.indentFirstLine) && p.indentFirstLine !== DEFAULT_PARA.indentFirstLine) if (p.indentFirstLine < 0) attrs.push(`w:hanging="${twips(-p.indentFirstLine)}"`);
 	else attrs.push(`w:firstLine="${twips(p.indentFirstLine)}"`);
 	return attrs.length > 0 ? `<w:ind ${attrs.join(" ")}/>` : "";
 }
 function spacingXml(p) {
 	const attrs = [];
-	if (p.spacingBefore !== DEFAULT_PARA.spacingBefore) attrs.push(`w:before="${twips(p.spacingBefore)}"`);
-	if (p.spacingAfter !== DEFAULT_PARA.spacingAfter) attrs.push(`w:after="${twips(p.spacingAfter)}"`);
+	if (stated(p.spacingBefore) && p.spacingBefore !== DEFAULT_PARA.spacingBefore) attrs.push(`w:before="${twips(p.spacingBefore)}"`);
+	if (stated(p.spacingAfter) && p.spacingAfter !== DEFAULT_PARA.spacingAfter) attrs.push(`w:after="${twips(p.spacingAfter)}"`);
 	if ((p.spacingLineRule !== DEFAULT_PARA.spacingLineRule || p.spacingLine !== DEFAULT_PARA.spacingLine) && p.spacingLine > 0) {
 		const lineVal = p.spacingLineRule === "auto" ? Math.round(p.spacingLine * 12) : twips(p.spacingLine);
 		attrs.push(`w:line="${lineVal}"`, `w:lineRule="${p.spacingLineRule}"`);
@@ -742,12 +804,12 @@ function levelXml(level) {
 }
 function rawParaPrXml(p) {
 	const attrs = [];
-	if (p.indentLeft !== void 0) attrs.push(`w:left="${twips(p.indentLeft)}"`);
-	if (p.indentRight !== void 0) attrs.push(`w:right="${twips(p.indentRight)}"`);
-	if (p.indentFirstLine !== void 0) if (p.indentFirstLine < 0) attrs.push(`w:hanging="${twips(-p.indentFirstLine)}"`);
+	if (p.indentLeft !== void 0 && stated(p.indentLeft)) attrs.push(`w:left="${twips(p.indentLeft)}"`);
+	if (p.indentRight !== void 0 && stated(p.indentRight)) attrs.push(`w:right="${twips(p.indentRight)}"`);
+	if (p.indentFirstLine !== void 0 && stated(p.indentFirstLine)) if (p.indentFirstLine < 0) attrs.push(`w:hanging="${twips(-p.indentFirstLine)}"`);
 	else attrs.push(`w:firstLine="${twips(p.indentFirstLine)}"`);
 	const ind = attrs.length > 0 ? `<w:ind ${attrs.join(" ")}/>` : "";
-	const jc = p.alignment !== void 0 ? `<w:jc w:val="${p.alignment}"/>` : "";
+	const jc = p.alignment !== void 0 && JC.has(p.alignment) ? `<w:jc w:val="${p.alignment}"/>` : "";
 	return ind || jc ? `<w:pPr>${jc}${ind}</w:pPr>` : "";
 }
 function rawRunPrXml(r) {

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

@@ -1042,7 +1042,11 @@ function vmlTextBox(shape, parseBody) {
 	const content = box ? poFindDescendant(box, "w:txbxContent") : void 0;
 	if (!content) return void 0;
 	const blocks = parseBody(poChildren(content));
-	return blocks.length > 0 ? { content: blocks } : void 0;
+	if (blocks.length === 0) return void 0;
+	return {
+		content: blocks,
+		upright: true
+	};
 }
 /**
 * The `@style` of a positioned VML shape as a float anchor: `position:absolute`
@@ -1653,11 +1657,13 @@ function parseTextBox(wsp, parseBody) {
 	const anchor = a === "ctr" ? "ctr" : a === "b" ? "b" : a === "t" ? "t" : void 0;
 	const v = bodyPr ? poAttr(bodyPr, "vert") : void 0;
 	const vertical = v === "vert270" ? "vert270" : v !== void 0 && v !== "horz" ? "vert" : void 0;
+	const upright = bodyPr !== void 0 && poAttr(bodyPr, "upright") === "1";
 	const autoFit = bodyPr !== void 0 && poChildren(bodyPr).some((c) => poIs(c, "a:spAutoFit"));
 	return {
 		content,
 		...chain ? { chain } : {},
 		...vertical ? { vertical } : {},
+		...upright ? { upright } : {},
 		...autoFit ? { autoFit: true } : {},
 		...lIns !== void 0 ? { insetLeft: emuToPt(lIns) } : {},
 		...tIns !== void 0 ? { insetTop: emuToPt(tIns) } : {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reamkit",
-  "version": "1.24.0",
+  "version": "1.25.1",
   "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.",
   "license": "MIT",
   "author": "Alex Krassavin <info@reamkit.dev>",