documents.js 1.45.0 → 1.46.1

package/README.md

@@ -30,7 +30,7 @@ npm install documents.js
 
 ## Usage
 
-The eight round-trip ergonomic conversions (docx/pptx/odt/odp ⇄ PDF), plus `odsToPdf`/`odgToPdf`'s one-directional additions (there is no `pdfToOds` yet — PDF → spreadsheet reconstruction needs general vector-path tracking in the PDF reader that doesn't exist yet; there is no `pdfToOdg` either, for the equivalent reason on the drawing side — see [Gotchas](#gotchas-and-quirks)):
+The eight round-trip ergonomic conversions (docx/pptx/odt/odp ⇄ PDF), plus `odsToPdf`/`odgToPdf`'s one-directional additions (there is no `pdfToOds`/`pdfToOdg` yet — the PDF reader's general vector-path tracking both directions need now exists (`src/pdf/interpret.ts`), but the reconstruction algorithms themselves, `reconstructSpreadsheet`/`reconstructDrawing`, are not yet built — see [Gotchas](#gotchas-and-quirks)):
 
 ```ts
 import { docxToPdf, odgToPdf, odpToPdf, odsToPdf, odtToPdf, pdfToDocx, pdfToOdp, pdfToOdt, pptxToPdf, pdfToPptx } from 'documents.js';
@@ -206,8 +206,9 @@ To run a single test file: `pnpm vitest run src/path/to/file.test.ts`.
 - **The docx⇄PDF and pptx⇄PDF conversions are explicitly not round-trip-lossless** — in deliberate contrast to `ooxml.js`'s own `packageCodec`, which is byte/part-faithful by design. See [Fidelity](#fidelity).
 - **`odpToPdf`/`pdfToOdp` needed zero new layout code.** `readOdpContent` (`src/odf/odp/read.ts`) produces the identical `presentation` `ContentDocument` shape `readPptxContent` does, so it feeds `convertPresentationToLayout` unmodified — including the existing hidden-annotation speaker-notes mechanism below, which carries odp's `presentation:notes` through to the PDF with no new notes-handling code at all; `pdfToOdp` reuses `reconstructPresentation` unmodified too, the same architectural bet `pdfToOdt` already proved for `reconstructWordprocessing`. The genuinely new work for the reverse direction was the live-view editor itself (`src/edit/odp/*`) — see Architecture above.
 - **`OdpShape.rotationDeg` writes a real `draw:transform`, built on `odf.js`'s own transform machinery.** It is the write-side inverse of `odf.js`'s `resolveOdfShapeGeometry` (`typed/shared/transform.ts`), built on that module's own exported `applyOdfTransform` rather than a hand-rolled rotation matrix, so it inherits that module's own empirically-verified rotate/translate composition order and sign convention by construction. Unlike `PptxShape` (see the `colSpan`/`rowSpan` gotcha below, which pptx still has and odp does not), `buildOdpPackage` writes a rotated shape's rotation back correctly — verified both by this package's own tests and by opening a fresh, editor-built `.odp` in actual LibreOffice.
-- **`odsToPdf` is one-directional — there is no `pdfToOds` yet, and no `reconstructSpreadsheet`.** Unlike odt/odp, going from PDF back to a spreadsheet needs general vector-path tracking in the PDF reader (`src/pdf/interpret.ts` currently only tracks the specific `re` rectangle operator, discarding general `m`/`l`/`c` path construction) so a reconstructed sheet's gridlines can be detected from the recovered geometry — that infrastructure doesn't exist yet. `buildOdsPackage` (`src/edit/ods/content.ts`) is built and exported, ready for `pdfToOds` to call the moment path tracking lands; nothing currently calls it.
-- **`odgToPdf` is one-directional — there is no `pdfToOdg`, and no `reconstructDrawing`, even though the odg live-view editor and `buildOdgPackage` both now exist.** Reconstructing a `ContentDrawPage`'s own vector-primitive geometry (which recovered path is a rect vs. a genuine curve, where one shape ends and another begins) from PDF geometry alone is a fundamentally different, unstarted problem from `reconstructWordprocessing`/`reconstructPresentation`'s own paragraph/shape geometry clustering — the same `src/pdf/interpret.ts` gap `odsToPdf`'s own gotcha above describes (no general `m`/`l`/`c` path tracking) blocks this direction too, on top of needing its own reconstruction algorithm even once that infrastructure exists. `buildOdgPackage` (`src/edit/odg/content.ts`) is built and exported, ready for `pdfToOdg` to call the moment both land; nothing currently calls it, mirroring `buildOdsPackage`'s own identical situation.
+- **`src/pdf/interpret.ts` now tracks general vector paths, not just axis-aligned `re` rectangles.** `m`/`l`/`c`/`v`/`y`/`h` (and `re` itself, per its own ISO 32000-1 definition as a 4-point rectangle subpath) accumulate real subpaths — CTM-transformed line/cubic segments, open or closed — and any paint operator (`f`/`F`/`f*`/`S`/`s`/`B`/`B*`/`b`/`b*`) emits a `LayoutPath` item when the path isn't reducible to the simple single-`re`-on-an-axis-aligned-CTM case (which still takes the original, unchanged `LayoutRect` fast path). Verified both by dedicated tests and by a genuine `writePath` → `writePdf` → `readPdf` round trip recovering the original `LayoutPath` value exactly. This is the shared infrastructure both `pdfToOds` and `pdfToOdg` below need — it exists now, but neither conversion function itself does yet.
+- **`odsToPdf` is one-directional — there is no `pdfToOds` yet, and no `reconstructSpreadsheet`.** The PDF-side blocker (general vector-path tracking, needed to detect a reconstructed sheet's gridlines from recovered geometry) is resolved — see the `interpret.ts` gotcha above. What's still missing is `reconstructSpreadsheet` itself: the actual gridline-detection/text-clustering-into-a-grid algorithm. `buildOdsPackage` (`src/edit/ods/content.ts`) is built and exported, ready for `pdfToOds` to call the moment that algorithm lands; nothing currently calls it.
+- **`odgToPdf` is one-directional — there is no `pdfToOdg`, and no `reconstructDrawing`, even though the odg live-view editor and `buildOdgPackage` both now exist.** The PDF-side blocker (general vector-path tracking) is resolved — see the `interpret.ts` gotcha above. What's still missing is `reconstructDrawing` itself: mapping recovered `LayoutRect`/`LayoutPath`/`LayoutText`/`LayoutImage` geometry back onto ODF shapes (which recovered path is a rect vs. a genuine curve, where one shape ends and another begins) — a fundamentally different, unstarted problem from `reconstructWordprocessing`/`reconstructPresentation`'s own paragraph/shape geometry clustering, though genuinely more tractable since a drawing has no semantic structure to infer, only shapes to map near-1:1. `buildOdgPackage` (`src/edit/odg/content.ts`) is built and exported, ready for `pdfToOdg` to call the moment that algorithm lands; nothing currently calls it, mirroring `buildOdsPackage`'s own identical situation.
 - **A vector primitive's own fill/stroke needed a self-contained graphic-family style writer, not `odf.js`'s own `StyleRegistry`.** `'graphic'` is a recognised `StyleFamily` member (`odf.js`'s `src/styles/registry.ts`), but `StylePropertiesSchema`/`buildStylePropertyElements` (`properties.ts`/`serialize.ts`) only ever model text/paragraph formatting and never emit a `style:graphic-properties` element for any family — extending that shared package for one narrow, documents.js-local need (`draw:fill(-color)`/`draw:stroke` + `svg:stroke-color`/`svg:stroke-width`) would be scope creep into a foreign package for a two-attribute-group writer this package can express directly. `src/edit/odg/style.ts` is that writer: it still reuses `odf.js`'s general append-only style-editing invariant (a setter always mints a fresh `style:style` and repoints `draw:style-name`, never mutates an existing entry — verified by the same `assertAutomaticStylesOnlyAppended` helper `OdpEditor`'s own live-view fidelity test uses) and `src/edit/odt/automatic-styles.ts`'s `ensureAutomaticStyles`/`nextStyleName` (the "find-or-create `office:automatic-styles`, mint the next unused name" logic every other hand-rolled style helper in this package already shares), rather than a third reimplementation of either.
 - **A path vector's own `svg:d` is cross-checked against `odf.js`'s real parser, not merely asserted to "look plausible".** `src/edit/odg/svg-path.ts`'s `buildSvgPathData` is the write-side inverse of `odf.js`'s `parseOdfPathData`; `OdgPathVector.subpaths` re-derives its value by reparsing the actual written `svg:viewBox`/`svg:d` through that exact function (plus `parseOdfViewBox`/`buildOdfSubpaths`) on every read, rather than echoing back whatever `ContentSubpath[]` the caller originally passed to `addPath` — so every read is itself a live round-trip proof, and this module's own test suite additionally feeds `buildSvgPathData`'s output straight into `parseOdfPathData` to confirm point-for-point recovery.
 - **A newly added vector/shape's paint order is expressed purely as document order, with no `draw:z-index` ever written.** This matches `odf.js`'s own reader-side convention exactly (`typed/draw/shapes.ts`'s `paintOrderKey`: honour an explicit `draw:z-index` when present, otherwise fall back to document order — and real LibreOffice output never emits one, it reorders elements instead), so `OdgPage.addRect`/`addEllipse`/`addLine`/`addPath`/`addTextBox`/`addImage` simply append to `draw:page`'s own children in call order and nothing more is needed for a later `add*` call to paint in front of an earlier one.

package/dist/index.cjs

@@ -7544,6 +7544,7 @@ function readInlineImage(reader, sink) {
 //#region src/pdf/interpret.ts
 const MAX_FORM_XOBJECT_DEPTH = 12;
 const FALLBACK_GLYPH_WIDTH_PER_1000 = 500;
+const DEFAULT_LINE_WIDTH_PT = 1;
 function defaultTextState() {
 	return {
 		tm: IDENTITY_MATRIX,
@@ -7636,16 +7637,118 @@ function interpretContentStream(bytes, resources, context) {
 	runContentStream(bytes, resources, {
 		ctm: IDENTITY_MATRIX,
 		fillColor: document_content_model.COLOR_BLACK,
-		strokeColor: document_content_model.COLOR_BLACK
+		strokeColor: document_content_model.COLOR_BLACK,
+		lineWidth: DEFAULT_LINE_WIDTH_PT
 	}, context, items, 0);
 	return items;
 }
+function lastPointOf(subpath) {
+	const last = subpath.segments[subpath.segments.length - 1];
+	return last === void 0 ? {
+		x: subpath.startXPt,
+		y: subpath.startYPt
+	} : {
+		x: last.xPt,
+		y: last.yPt
+	};
+}
 function runContentStream(bytes, resources, initialState, context, items, depth) {
 	const operations = readContentStream(bytes, context.sink);
 	const gsStack = [];
 	let gs = initialState;
 	let ts = defaultTextState();
 	let pendingRect;
+	let pathSubpaths = [];
+	let currentSubpath;
+	const finalizeCurrentSubpath = () => {
+		if (currentSubpath !== void 0) {
+			pathSubpaths.push(currentSubpath);
+			currentSubpath = void 0;
+		}
+	};
+	const resetPath = () => {
+		pendingRect = void 0;
+		pathSubpaths = [];
+		currentSubpath = void 0;
+	};
+	const appendRectSubpath = (operands, ctm) => {
+		finalizeCurrentSubpath();
+		const x = numAt(operands, 0);
+		const y = numAt(operands, 1);
+		const w = numAt(operands, 2);
+		const h = numAt(operands, 3);
+		const p1 = applyMatrix(ctm, {
+			x,
+			y
+		});
+		const p2 = applyMatrix(ctm, {
+			x: x + w,
+			y
+		});
+		const p3 = applyMatrix(ctm, {
+			x: x + w,
+			y: y + h
+		});
+		const p4 = applyMatrix(ctm, {
+			x,
+			y: y + h
+		});
+		pathSubpaths.push({
+			startXPt: p1.x,
+			startYPt: p1.y,
+			segments: [
+				{
+					kind: "line",
+					xPt: p2.x,
+					yPt: p2.y
+				},
+				{
+					kind: "line",
+					xPt: p3.x,
+					yPt: p3.y
+				},
+				{
+					kind: "line",
+					xPt: p4.x,
+					yPt: p4.y
+				}
+			],
+			closed: true
+		});
+	};
+	const paintFillRuleFor = (operator) => operator.endsWith("*") ? "evenodd" : "nonzero";
+	const emitPaint = (operator) => {
+		if (operator === "n") {
+			resetPath();
+			return;
+		}
+		if ((operator === "s" || operator === "b" || operator === "b*") && currentSubpath !== void 0) currentSubpath.closed = true;
+		if ((operator === "f" || operator === "F" || operator === "f*") && currentSubpath === void 0 && pathSubpaths.length === 1 && pendingRect !== void 0) {
+			items.push({
+				kind: "rect",
+				...pendingRect,
+				color: gs.fillColor
+			});
+			resetPath();
+			return;
+		}
+		finalizeCurrentSubpath();
+		if (pathSubpaths.length > 0) {
+			const isFillOp = operator === "f" || operator === "F" || operator === "f*" || operator === "B" || operator === "B*" || operator === "b" || operator === "b*";
+			const isStrokeOp = operator === "S" || operator === "s" || operator === "B" || operator === "B*" || operator === "b" || operator === "b*";
+			items.push({
+				kind: "path",
+				subpaths: pathSubpaths,
+				fillRule: paintFillRuleFor(operator),
+				fill: isFillOp ? gs.fillColor : void 0,
+				stroke: isStrokeOp ? {
+					color: gs.strokeColor,
+					widthPt: gs.lineWidth
+				} : void 0
+			});
+		}
+		resetPath();
+	};
 	const advanceThroughString = (codes) => {
 		if (ts.fontResourceName === void 0) return;
 		let offset = 0;
@@ -7829,25 +7932,118 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 			}
 			case "re":
 				pendingRect = rectFromOperands(operands, gs.ctm);
+				appendRectSubpath(operands, gs.ctm);
+				break;
+			case "m": {
+				finalizeCurrentSubpath();
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				currentSubpath = {
+					startXPt: p.x,
+					startYPt: p.y,
+					segments: [],
+					closed: false
+				};
+				pendingRect = void 0;
+				break;
+			}
+			case "l": {
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				currentSubpath?.segments.push({
+					kind: "line",
+					xPt: p.x,
+					yPt: p.y
+				});
+				pendingRect = void 0;
 				break;
-			case "m":
-			case "l":
-			case "c":
+			}
+			case "c": {
+				const c1 = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				const c2 = applyMatrix(gs.ctm, {
+					x: numAt(operands, 2),
+					y: numAt(operands, 3)
+				});
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 4),
+					y: numAt(operands, 5)
+				});
+				currentSubpath?.segments.push({
+					kind: "cubic",
+					c1xPt: c1.x,
+					c1yPt: c1.y,
+					c2xPt: c2.x,
+					c2yPt: c2.y,
+					xPt: p.x,
+					yPt: p.y
+				});
+				pendingRect = void 0;
+				break;
+			}
 			case "v":
-			case "y":
+				if (currentSubpath !== void 0) {
+					const cur = lastPointOf(currentSubpath);
+					const c2 = applyMatrix(gs.ctm, {
+						x: numAt(operands, 0),
+						y: numAt(operands, 1)
+					});
+					const p = applyMatrix(gs.ctm, {
+						x: numAt(operands, 2),
+						y: numAt(operands, 3)
+					});
+					currentSubpath.segments.push({
+						kind: "cubic",
+						c1xPt: cur.x,
+						c1yPt: cur.y,
+						c2xPt: c2.x,
+						c2yPt: c2.y,
+						xPt: p.x,
+						yPt: p.y
+					});
+				}
+				pendingRect = void 0;
+				break;
+			case "y": {
+				const c1 = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 2),
+					y: numAt(operands, 3)
+				});
+				currentSubpath?.segments.push({
+					kind: "cubic",
+					c1xPt: c1.x,
+					c1yPt: c1.y,
+					c2xPt: p.x,
+					c2yPt: p.y,
+					xPt: p.x,
+					yPt: p.y
+				});
+				pendingRect = void 0;
+				break;
+			}
 			case "h":
+				if (currentSubpath !== void 0) currentSubpath.closed = true;
 				pendingRect = void 0;
 				break;
+			case "w":
+				gs = {
+					...gs,
+					lineWidth: numAt(operands, 0)
+				};
+				break;
 			case "f":
 			case "F":
 			case "f*":
-				if (pendingRect !== void 0) items.push({
-					kind: "rect",
-					...pendingRect,
-					color: gs.fillColor
-				});
-				pendingRect = void 0;
-				break;
 			case "S":
 			case "s":
 			case "B":
@@ -7855,7 +8051,7 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 			case "b":
 			case "b*":
 			case "n":
-				pendingRect = void 0;
+				emitPaint(operator);
 				break;
 			case "BT":
 				ts = defaultTextState();
@@ -8837,6 +9033,7 @@ function readPage(page, resolver, fontResolver, images, imageIdCache, sink) {
 function convertExtractedItem(item, pageMatrix, fontResolver, images, imageIdCache, resolver, sink) {
 	if (item.kind === "text") return convertText(item, pageMatrix, fontResolver);
 	if (item.kind === "rect") return convertRect(item, pageMatrix);
+	if (item.kind === "path") return convertPath(item, pageMatrix);
 	if (item.kind === "image") return convertImage(item, pageMatrix, images, imageIdCache, resolver, sink);
 	return convertInlineImage(item, pageMatrix, images, resolver, sink);
 }
@@ -8884,6 +9081,61 @@ function convertRect(item, pageMatrix) {
 		fill: item.color
 	};
 }
+function transformSubpath(subpath, pageMatrix) {
+	const start = applyMatrix(pageMatrix, {
+		x: subpath.startXPt,
+		y: subpath.startYPt
+	});
+	const segments = subpath.segments.map((segment) => {
+		if (segment.kind === "line") {
+			const p = applyMatrix(pageMatrix, {
+				x: segment.xPt,
+				y: segment.yPt
+			});
+			return {
+				kind: "line",
+				xPt: p.x,
+				yPt: p.y
+			};
+		}
+		const c1 = applyMatrix(pageMatrix, {
+			x: segment.c1xPt,
+			y: segment.c1yPt
+		});
+		const c2 = applyMatrix(pageMatrix, {
+			x: segment.c2xPt,
+			y: segment.c2yPt
+		});
+		const p = applyMatrix(pageMatrix, {
+			x: segment.xPt,
+			y: segment.yPt
+		});
+		return {
+			kind: "cubic",
+			c1xPt: c1.x,
+			c1yPt: c1.y,
+			c2xPt: c2.x,
+			c2yPt: c2.y,
+			xPt: p.x,
+			yPt: p.y
+		};
+	});
+	return {
+		startXPt: start.x,
+		startYPt: start.y,
+		segments,
+		closed: subpath.closed
+	};
+}
+function convertPath(item, pageMatrix) {
+	return {
+		kind: "path",
+		subpaths: item.subpaths.map((subpath) => transformSubpath(subpath, pageMatrix)),
+		...item.fill !== void 0 ? { fill: item.fill } : {},
+		...item.fill !== void 0 && item.fillRule === "evenodd" ? { fillRule: "evenodd" } : {},
+		...item.stroke !== void 0 ? { stroke: item.stroke } : {}
+	};
+}
 function imagePlacementFrom(matrix) {
 	const rotationDeg = matrixRotationDegrees(matrix);
 	return {

package/dist/index.js

@@ -7543,6 +7543,7 @@ function readInlineImage(reader, sink) {
 //#region src/pdf/interpret.ts
 const MAX_FORM_XOBJECT_DEPTH = 12;
 const FALLBACK_GLYPH_WIDTH_PER_1000 = 500;
+const DEFAULT_LINE_WIDTH_PT = 1;
 function defaultTextState() {
 	return {
 		tm: IDENTITY_MATRIX,
@@ -7635,16 +7636,118 @@ function interpretContentStream(bytes, resources, context) {
 	runContentStream(bytes, resources, {
 		ctm: IDENTITY_MATRIX,
 		fillColor: COLOR_BLACK,
-		strokeColor: COLOR_BLACK
+		strokeColor: COLOR_BLACK,
+		lineWidth: DEFAULT_LINE_WIDTH_PT
 	}, context, items, 0);
 	return items;
 }
+function lastPointOf(subpath) {
+	const last = subpath.segments[subpath.segments.length - 1];
+	return last === void 0 ? {
+		x: subpath.startXPt,
+		y: subpath.startYPt
+	} : {
+		x: last.xPt,
+		y: last.yPt
+	};
+}
 function runContentStream(bytes, resources, initialState, context, items, depth) {
 	const operations = readContentStream(bytes, context.sink);
 	const gsStack = [];
 	let gs = initialState;
 	let ts = defaultTextState();
 	let pendingRect;
+	let pathSubpaths = [];
+	let currentSubpath;
+	const finalizeCurrentSubpath = () => {
+		if (currentSubpath !== void 0) {
+			pathSubpaths.push(currentSubpath);
+			currentSubpath = void 0;
+		}
+	};
+	const resetPath = () => {
+		pendingRect = void 0;
+		pathSubpaths = [];
+		currentSubpath = void 0;
+	};
+	const appendRectSubpath = (operands, ctm) => {
+		finalizeCurrentSubpath();
+		const x = numAt(operands, 0);
+		const y = numAt(operands, 1);
+		const w = numAt(operands, 2);
+		const h = numAt(operands, 3);
+		const p1 = applyMatrix(ctm, {
+			x,
+			y
+		});
+		const p2 = applyMatrix(ctm, {
+			x: x + w,
+			y
+		});
+		const p3 = applyMatrix(ctm, {
+			x: x + w,
+			y: y + h
+		});
+		const p4 = applyMatrix(ctm, {
+			x,
+			y: y + h
+		});
+		pathSubpaths.push({
+			startXPt: p1.x,
+			startYPt: p1.y,
+			segments: [
+				{
+					kind: "line",
+					xPt: p2.x,
+					yPt: p2.y
+				},
+				{
+					kind: "line",
+					xPt: p3.x,
+					yPt: p3.y
+				},
+				{
+					kind: "line",
+					xPt: p4.x,
+					yPt: p4.y
+				}
+			],
+			closed: true
+		});
+	};
+	const paintFillRuleFor = (operator) => operator.endsWith("*") ? "evenodd" : "nonzero";
+	const emitPaint = (operator) => {
+		if (operator === "n") {
+			resetPath();
+			return;
+		}
+		if ((operator === "s" || operator === "b" || operator === "b*") && currentSubpath !== void 0) currentSubpath.closed = true;
+		if ((operator === "f" || operator === "F" || operator === "f*") && currentSubpath === void 0 && pathSubpaths.length === 1 && pendingRect !== void 0) {
+			items.push({
+				kind: "rect",
+				...pendingRect,
+				color: gs.fillColor
+			});
+			resetPath();
+			return;
+		}
+		finalizeCurrentSubpath();
+		if (pathSubpaths.length > 0) {
+			const isFillOp = operator === "f" || operator === "F" || operator === "f*" || operator === "B" || operator === "B*" || operator === "b" || operator === "b*";
+			const isStrokeOp = operator === "S" || operator === "s" || operator === "B" || operator === "B*" || operator === "b" || operator === "b*";
+			items.push({
+				kind: "path",
+				subpaths: pathSubpaths,
+				fillRule: paintFillRuleFor(operator),
+				fill: isFillOp ? gs.fillColor : void 0,
+				stroke: isStrokeOp ? {
+					color: gs.strokeColor,
+					widthPt: gs.lineWidth
+				} : void 0
+			});
+		}
+		resetPath();
+	};
 	const advanceThroughString = (codes) => {
 		if (ts.fontResourceName === void 0) return;
 		let offset = 0;
@@ -7828,25 +7931,118 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 			}
 			case "re":
 				pendingRect = rectFromOperands(operands, gs.ctm);
+				appendRectSubpath(operands, gs.ctm);
+				break;
+			case "m": {
+				finalizeCurrentSubpath();
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				currentSubpath = {
+					startXPt: p.x,
+					startYPt: p.y,
+					segments: [],
+					closed: false
+				};
+				pendingRect = void 0;
+				break;
+			}
+			case "l": {
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				currentSubpath?.segments.push({
+					kind: "line",
+					xPt: p.x,
+					yPt: p.y
+				});
+				pendingRect = void 0;
 				break;
-			case "m":
-			case "l":
-			case "c":
+			}
+			case "c": {
+				const c1 = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				const c2 = applyMatrix(gs.ctm, {
+					x: numAt(operands, 2),
+					y: numAt(operands, 3)
+				});
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 4),
+					y: numAt(operands, 5)
+				});
+				currentSubpath?.segments.push({
+					kind: "cubic",
+					c1xPt: c1.x,
+					c1yPt: c1.y,
+					c2xPt: c2.x,
+					c2yPt: c2.y,
+					xPt: p.x,
+					yPt: p.y
+				});
+				pendingRect = void 0;
+				break;
+			}
 			case "v":
-			case "y":
+				if (currentSubpath !== void 0) {
+					const cur = lastPointOf(currentSubpath);
+					const c2 = applyMatrix(gs.ctm, {
+						x: numAt(operands, 0),
+						y: numAt(operands, 1)
+					});
+					const p = applyMatrix(gs.ctm, {
+						x: numAt(operands, 2),
+						y: numAt(operands, 3)
+					});
+					currentSubpath.segments.push({
+						kind: "cubic",
+						c1xPt: cur.x,
+						c1yPt: cur.y,
+						c2xPt: c2.x,
+						c2yPt: c2.y,
+						xPt: p.x,
+						yPt: p.y
+					});
+				}
+				pendingRect = void 0;
+				break;
+			case "y": {
+				const c1 = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 2),
+					y: numAt(operands, 3)
+				});
+				currentSubpath?.segments.push({
+					kind: "cubic",
+					c1xPt: c1.x,
+					c1yPt: c1.y,
+					c2xPt: p.x,
+					c2yPt: p.y,
+					xPt: p.x,
+					yPt: p.y
+				});
+				pendingRect = void 0;
+				break;
+			}
 			case "h":
+				if (currentSubpath !== void 0) currentSubpath.closed = true;
 				pendingRect = void 0;
 				break;
+			case "w":
+				gs = {
+					...gs,
+					lineWidth: numAt(operands, 0)
+				};
+				break;
 			case "f":
 			case "F":
 			case "f*":
-				if (pendingRect !== void 0) items.push({
-					kind: "rect",
-					...pendingRect,
-					color: gs.fillColor
-				});
-				pendingRect = void 0;
-				break;
 			case "S":
 			case "s":
 			case "B":
@@ -7854,7 +8050,7 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 			case "b":
 			case "b*":
 			case "n":
-				pendingRect = void 0;
+				emitPaint(operator);
 				break;
 			case "BT":
 				ts = defaultTextState();
@@ -8836,6 +9032,7 @@ function readPage(page, resolver, fontResolver, images, imageIdCache, sink) {
 function convertExtractedItem(item, pageMatrix, fontResolver, images, imageIdCache, resolver, sink) {
 	if (item.kind === "text") return convertText(item, pageMatrix, fontResolver);
 	if (item.kind === "rect") return convertRect(item, pageMatrix);
+	if (item.kind === "path") return convertPath(item, pageMatrix);
 	if (item.kind === "image") return convertImage(item, pageMatrix, images, imageIdCache, resolver, sink);
 	return convertInlineImage(item, pageMatrix, images, resolver, sink);
 }
@@ -8883,6 +9080,61 @@ function convertRect(item, pageMatrix) {
 		fill: item.color
 	};
 }
+function transformSubpath(subpath, pageMatrix) {
+	const start = applyMatrix(pageMatrix, {
+		x: subpath.startXPt,
+		y: subpath.startYPt
+	});
+	const segments = subpath.segments.map((segment) => {
+		if (segment.kind === "line") {
+			const p = applyMatrix(pageMatrix, {
+				x: segment.xPt,
+				y: segment.yPt
+			});
+			return {
+				kind: "line",
+				xPt: p.x,
+				yPt: p.y
+			};
+		}
+		const c1 = applyMatrix(pageMatrix, {
+			x: segment.c1xPt,
+			y: segment.c1yPt
+		});
+		const c2 = applyMatrix(pageMatrix, {
+			x: segment.c2xPt,
+			y: segment.c2yPt
+		});
+		const p = applyMatrix(pageMatrix, {
+			x: segment.xPt,
+			y: segment.yPt
+		});
+		return {
+			kind: "cubic",
+			c1xPt: c1.x,
+			c1yPt: c1.y,
+			c2xPt: c2.x,
+			c2yPt: c2.y,
+			xPt: p.x,
+			yPt: p.y
+		};
+	});
+	return {
+		startXPt: start.x,
+		startYPt: start.y,
+		segments,
+		closed: subpath.closed
+	};
+}
+function convertPath(item, pageMatrix) {
+	return {
+		kind: "path",
+		subpaths: item.subpaths.map((subpath) => transformSubpath(subpath, pageMatrix)),
+		...item.fill !== void 0 ? { fill: item.fill } : {},
+		...item.fill !== void 0 && item.fillRule === "evenodd" ? { fillRule: "evenodd" } : {},
+		...item.stroke !== void 0 ? { stroke: item.stroke } : {}
+	};
+}
 function imagePlacementFrom(matrix) {
 	const rotationDeg = matrixRotationDegrees(matrix);
 	return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "documents.js",
-  "version": "1.45.0",
+  "version": "1.46.1",
   "description": "Bidirectional docx/pptx <-> PDF conversion and a read+write editable OOXML document model, built on ooxml.js and Zod 4 codecs.",
   "type": "module",
   "repository": {