pdf-parser.js 5.1.0 → 5.2.1

package/README.md

@@ -333,7 +333,25 @@ A run whose `widthPt` is absent states no advance, so where it ends is unknown a
 
 Gaps that are derivable become a word space at an eighth of an em (the narrowest genuine one: the standard fourteen faces set their space glyph at 250/1000 em, and justified setting compresses to no less than half of that) and a column boundary past a full em (wider than the em space, the widest single space character there is), so a table's row reads as `"North\t4.2m\t11%"` rather than as one sentence. `runsShareBaseline` and `runGapPt` are exported on their own for a consumer with its own pipeline around them, and every threshold is overridable.
 
-Limits, each inherent to what a PDF states rather than to the implementation: grouping is by baseline alone with no page segmentation, so on a multi-column page whose columns sit at different vertical offsets a line of one can fall within tolerance of a line of the next and the two are reported as one line with a column boundary between them, which is the cut a caller needs (`document-outline.js`'s `segmentPdfRegions` finds the gutter first if you want them genuinely apart); text comes out in visual order, so a right-to-left script needs the Unicode Bidi Algorithm applied to the result; vertical writing modes are not recognised, because the content interpreter does not read a CMap's `WMode` ([#1358](https://github.com/ExaDev/documents.js/issues/1358)); and a word hyphenated across a line end stays split, hyphen intact, because rejoining it is a paragraph-level judgement this package leaves to its consumers.
+Limits, each inherent to what a PDF states rather than to the implementation: grouping is by baseline alone with no page segmentation, so on a multi-column page whose columns sit at different vertical offsets a line of one can fall within tolerance of a line of the next and the two are reported as one line with a column boundary between them, which is the cut a caller needs (`document-outline.js`'s `segmentPdfRegions` finds the gutter first if you want them genuinely apart); text comes out in visual order, so a right-to-left script needs the Unicode Bidi Algorithm applied to the result; a vertically set run groups into a column instead of a line, reported with a `rotationDeg` of 270 and its own `writingMode`, with columns ordered right to left; and a word hyphenated across a line end stays split, hyphen intact, because rejoining it is a paragraph-level judgement this package leaves to its consumers.
+
+## Vertical writing mode
+
+A composite font's `/Encoding` CMap chooses a writing mode (ISO 32000-1 9.7.5.1). Mode 1 is vertical: the glyphs stay upright but the text position advances **down** the page, by the descendant CIDFont's own `/DW2` and `/W2` vertical metrics rather than by its horizontal widths, and each glyph paints offset from that position by its own position vector. `readPdf` reads all of it ([#1358](https://github.com/ExaDev/documents.js/issues/1358)), from a predefined CMap's `-V` name, from the bare `V` CMap, or from an embedded CMap stream's own `/WMode`.
+
+A vertically set run carries `writingMode: "vertical"`, and that is a separate fact from `rotationDeg`, which reports the text rendering matrix turning the glyphs themselves on their side. An ordinary Japanese column is `writingMode: "vertical"` with a `rotationDeg` of 0: upright glyphs, running downward. On such a run, `xPt`/`yPt` is the top of the column and `widthPt` measures downward.
+
+```ts
+const runs = page.items.filter((item) => item.kind === "text");
+for (const line of groupPdfTextRuns(runs)) {
+  // A vertical column reports rotationDeg 270 (the direction it advances) and writingMode "vertical".
+  console.log(line.writingMode ?? "horizontal", line.text);
+}
+```
+
+`groupPdfTextRuns` groups such runs into columns, ordered right to left, and never lets a column and a line merge even when they advance along the same axis: a column of upright glyphs and a line of glyphs turned on their side are not the same text, whatever direction they share.
+
+What is not supported: a **predefined non-Identity CMap's own byte decoding**. `90ms-RKSJ-V` and its siblings remap multi-byte character codes to CIDs through tables this package does not carry, so a font using one still has its codes read as two-byte CIDs. That is this package's long-standing composite-font limit, unchanged by and unrelated to writing mode; `Identity-V` (what modern producers emit) is read exactly. `writePdf` produces horizontal text only, and has no way to request a vertical one.
 
 ## JBIG2 scope
 

package/dist/codec.d.cts

@@ -54,6 +54,7 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
       }, z.core.$strip>;
       widthPt: z.ZodOptional<z.ZodNumber>;
       rotationDeg: z.ZodOptional<z.ZodNumber>;
+      writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
       underline: z.ZodOptional<z.ZodBoolean>;
       layer: z.ZodOptional<z.ZodString>;
       actualText: z.ZodOptional<z.ZodString>;

package/dist/codec.d.ts

@@ -54,6 +54,7 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
       }, z.core.$strip>;
       widthPt: z.ZodOptional<z.ZodNumber>;
       rotationDeg: z.ZodOptional<z.ZodNumber>;
+      writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
       underline: z.ZodOptional<z.ZodBoolean>;
       layer: z.ZodOptional<z.ZodString>;
       actualText: z.ZodOptional<z.ZodString>;

package/dist/font-read.cjs

@@ -177,6 +177,63 @@ function readCidWidths(w) {
 	return map;
 }
 const DEFAULT_CID_WIDTH = 1e3;
+const DEFAULT_VERTICAL_POSITION_Y = 880;
+const DEFAULT_VERTICAL_DISPLACEMENT_Y = -1e3;
+const DW2_ENTRY_COUNT = 2;
+const W2_TRIPLET_LENGTH = 3;
+const VERTICAL_WRITING_MODE = 1;
+function readCidVerticalMetrics(w2) {
+	const map = /* @__PURE__ */ new Map();
+	if (w2 === void 0) return map;
+	let i = 0;
+	while (i < w2.length) {
+		const first = require_objects.asNumber(w2[i]);
+		if (first === void 0) {
+			i++;
+			continue;
+		}
+		const next = w2[i + 1];
+		if (next?.kind === "array") {
+			tripletsOf(next.items).forEach((triplet, index) => {
+				const entry = verticalEntryFrom(require_objects.asNumber(triplet[0]), require_objects.asNumber(triplet[1]), require_objects.asNumber(triplet[2]));
+				if (entry !== void 0) map.set(first + index, entry);
+			});
+			i += 2;
+			continue;
+		}
+		const last = require_objects.asNumber(next);
+		const entry = verticalEntryFrom(require_objects.asNumber(w2[i + 2]), require_objects.asNumber(w2[i + 3]), require_objects.asNumber(w2[i + 4]));
+		if (last !== void 0 && entry !== void 0) for (let cid = first; cid <= last; cid++) map.set(cid, entry);
+		i += 5;
+	}
+	return map;
+}
+function tripletsOf(items) {
+	const groups = [];
+	for (const item of items) {
+		const last = groups[groups.length - 1];
+		if (last !== void 0 && last.length < W2_TRIPLET_LENGTH) last.push(item);
+		else groups.push([item]);
+	}
+	return groups;
+}
+function verticalEntryFrom(displacementY, positionX, positionY) {
+	if (displacementY === void 0 || positionX === void 0 || positionY === void 0) return;
+	return {
+		displacementY,
+		positionX,
+		positionY
+	};
+}
+function predefinedCMapIsVertical(name) {
+	return name === "V" || name.endsWith("-V");
+}
+function readsVertically(fontDict, context) {
+	const encoding = context.resolver.resolve(require_objects.dictGet(fontDict, "Encoding"));
+	if (encoding?.kind === "name") return predefinedCMapIsVertical(encoding.name);
+	if (encoding?.kind === "stream") return require_objects.asNumber(require_objects.dictGet(encoding.dict, "WMode")) === VERTICAL_WRITING_MODE;
+	return false;
+}
 function buildCompositeFont(fontDict, context) {
 	const baseFont = require_objects.asName(require_objects.dictGet(fontDict, "BaseFont")) ?? "Helvetica";
 	const descendants = require_objects.asArray(require_objects.dictGet(fontDict, "DescendantFonts"));
@@ -186,9 +243,22 @@ function buildCompositeFont(fontDict, context) {
 	const dw = descendantDict !== void 0 ? require_objects.asNumber(require_objects.dictGet(descendantDict, "DW")) ?? DEFAULT_CID_WIDTH : DEFAULT_CID_WIDTH;
 	const widthMap = readCidWidths(descendantDict !== void 0 ? require_objects.asArray(require_objects.dictGet(descendantDict, "W")) : void 0);
 	const widthOf = (cid) => widthMap.get(cid) ?? dw;
+	const dw2 = descendantDict !== void 0 ? require_objects.asArray(require_objects.dictGet(descendantDict, "DW2")) : void 0;
+	const defaultPositionY = (dw2?.length === DW2_ENTRY_COUNT ? require_objects.asNumber(dw2[0]) : void 0) ?? DEFAULT_VERTICAL_POSITION_Y;
+	const defaultDisplacementY = (dw2?.length === DW2_ENTRY_COUNT ? require_objects.asNumber(dw2[1]) : void 0) ?? DEFAULT_VERTICAL_DISPLACEMENT_Y;
+	const verticalMap = readCidVerticalMetrics(descendantDict !== void 0 ? require_objects.asArray(require_objects.dictGet(descendantDict, "W2")) : void 0);
+	const verticalMetricsOf = (cid) => {
+		const entry = verticalMap.get(cid);
+		return {
+			displacementY: entry?.displacementY ?? defaultDisplacementY,
+			positionX: entry?.positionX ?? widthOf(cid) / 2,
+			positionY: entry?.positionY ?? defaultPositionY
+		};
+	};
 	const toUnicode = readToUnicodeCMap(fontDict, context);
 	const cidToGidMap = descendantDict !== void 0 ? require_objects.dictGet(descendantDict, "CIDToGIDMap") : void 0;
-	const programEncoding = require_objects.isName(require_objects.dictGet(fontDict, "Encoding"), "Identity-H") && (cidToGidMap === void 0 || require_objects.isName(cidToGidMap, "Identity")) ? lazyFontProgram(descriptor, context) : void 0;
+	const encodingName = require_objects.dictGet(fontDict, "Encoding");
+	const programEncoding = (require_objects.isName(encodingName, "Identity-H") || require_objects.isName(encodingName, "Identity-V")) && (cidToGidMap === void 0 || require_objects.isName(cidToGidMap, "Identity")) ? lazyFontProgram(descriptor, context) : void 0;
 	const decodeToUnicode = (codes) => {
 		let out = "";
 		let glyphCount = 0;
@@ -222,7 +292,8 @@ function buildCompositeFont(fontDict, context) {
 		bold,
 		italic,
 		widthOf,
-		decodeToUnicode
+		decodeToUnicode,
+		...readsVertically(fontDict, context) ? { verticalMetricsOf } : {}
 	};
 }
 function createFontResolver(context) {
@@ -237,16 +308,27 @@ function createFontResolver(context) {
 		return resolved;
 	};
 	return {
-		metrics: { glyphAdvance(fontResourceName, resources, codes, byteOffset) {
-			const font = resolve(fontResourceName, resources);
-			if (font === void 0) return;
-			const byteLengthConsumed = font.composite ? 2 : 1;
-			const code = font.composite ? (codes[byteOffset] ?? 0) << 8 | (codes[byteOffset + 1] ?? 0) : codes[byteOffset] ?? 0;
-			return {
-				widthPer1000: font.widthOf(code),
-				byteLengthConsumed
-			};
-		} },
+		metrics: {
+			glyphAdvance(fontResourceName, resources, codes, byteOffset) {
+				const font = resolve(fontResourceName, resources);
+				if (font === void 0) return;
+				const byteLengthConsumed = font.composite ? 2 : 1;
+				const code = font.composite ? (codes[byteOffset] ?? 0) << 8 | (codes[byteOffset + 1] ?? 0) : codes[byteOffset] ?? 0;
+				const vertical = font.verticalMetricsOf?.(code);
+				return {
+					widthPer1000: font.widthOf(code),
+					byteLengthConsumed,
+					...vertical === void 0 ? {} : { vertical: {
+						displacementPer1000: vertical.displacementY,
+						positionXPer1000: vertical.positionX,
+						positionYPer1000: vertical.positionY
+					} }
+				};
+			},
+			isVertical(fontResourceName, resources) {
+				return resolve(fontResourceName, resources)?.verticalMetricsOf !== void 0;
+			}
+		},
 		resolve
 	};
 }

package/dist/font-read.d.cts

@@ -2,6 +2,11 @@ import { PdfDiagnosticSink } from "./diagnostics.cjs";
 import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
 import { FontMetricsPort, PdfObjectResolver } from "./interpret.cjs";
 //#region src/font-read.d.ts
+interface VerticalGlyphMetrics {
+  readonly displacementY: number;
+  readonly positionX: number;
+  readonly positionY: number;
+}
 interface PdfFont {
   readonly composite: boolean;
   readonly family: string;
@@ -9,6 +14,7 @@ interface PdfFont {
   readonly italic: boolean;
   widthOf(code: number): number;
   decodeToUnicode(codes: Uint8Array<ArrayBuffer>): string;
+  readonly verticalMetricsOf?: (code: number) => VerticalGlyphMetrics;
 }
 interface FontReadContext {
   readonly resolver: PdfObjectResolver;
@@ -20,4 +26,4 @@ interface FontResolverService {
 }
 declare function createFontResolver(context: FontReadContext): FontResolverService;
 //#endregion
-export { FontReadContext, FontResolverService, PdfFont, createFontResolver };
+export { FontReadContext, FontResolverService, PdfFont, VerticalGlyphMetrics, createFontResolver };

package/dist/font-read.d.ts

@@ -2,6 +2,11 @@ import { PdfDiagnosticSink } from "./diagnostics.js";
 import { n as PdfDict } from "./objects-B7HdMeWS.js";
 import { FontMetricsPort, PdfObjectResolver } from "./interpret.js";
 //#region src/font-read.d.ts
+interface VerticalGlyphMetrics {
+  readonly displacementY: number;
+  readonly positionX: number;
+  readonly positionY: number;
+}
 interface PdfFont {
   readonly composite: boolean;
   readonly family: string;
@@ -9,6 +14,7 @@ interface PdfFont {
   readonly italic: boolean;
   widthOf(code: number): number;
   decodeToUnicode(codes: Uint8Array<ArrayBuffer>): string;
+  readonly verticalMetricsOf?: (code: number) => VerticalGlyphMetrics;
 }
 interface FontReadContext {
   readonly resolver: PdfObjectResolver;
@@ -20,4 +26,4 @@ interface FontResolverService {
 }
 declare function createFontResolver(context: FontReadContext): FontResolverService;
 //#endregion
-export { FontReadContext, FontResolverService, PdfFont, createFontResolver };
+export { FontReadContext, FontResolverService, PdfFont, VerticalGlyphMetrics, createFontResolver };

package/dist/font-read.js

@@ -176,6 +176,63 @@ function readCidWidths(w) {
 	return map;
 }
 const DEFAULT_CID_WIDTH = 1e3;
+const DEFAULT_VERTICAL_POSITION_Y = 880;
+const DEFAULT_VERTICAL_DISPLACEMENT_Y = -1e3;
+const DW2_ENTRY_COUNT = 2;
+const W2_TRIPLET_LENGTH = 3;
+const VERTICAL_WRITING_MODE = 1;
+function readCidVerticalMetrics(w2) {
+	const map = /* @__PURE__ */ new Map();
+	if (w2 === void 0) return map;
+	let i = 0;
+	while (i < w2.length) {
+		const first = asNumber(w2[i]);
+		if (first === void 0) {
+			i++;
+			continue;
+		}
+		const next = w2[i + 1];
+		if (next?.kind === "array") {
+			tripletsOf(next.items).forEach((triplet, index) => {
+				const entry = verticalEntryFrom(asNumber(triplet[0]), asNumber(triplet[1]), asNumber(triplet[2]));
+				if (entry !== void 0) map.set(first + index, entry);
+			});
+			i += 2;
+			continue;
+		}
+		const last = asNumber(next);
+		const entry = verticalEntryFrom(asNumber(w2[i + 2]), asNumber(w2[i + 3]), asNumber(w2[i + 4]));
+		if (last !== void 0 && entry !== void 0) for (let cid = first; cid <= last; cid++) map.set(cid, entry);
+		i += 5;
+	}
+	return map;
+}
+function tripletsOf(items) {
+	const groups = [];
+	for (const item of items) {
+		const last = groups[groups.length - 1];
+		if (last !== void 0 && last.length < W2_TRIPLET_LENGTH) last.push(item);
+		else groups.push([item]);
+	}
+	return groups;
+}
+function verticalEntryFrom(displacementY, positionX, positionY) {
+	if (displacementY === void 0 || positionX === void 0 || positionY === void 0) return;
+	return {
+		displacementY,
+		positionX,
+		positionY
+	};
+}
+function predefinedCMapIsVertical(name) {
+	return name === "V" || name.endsWith("-V");
+}
+function readsVertically(fontDict, context) {
+	const encoding = context.resolver.resolve(dictGet(fontDict, "Encoding"));
+	if (encoding?.kind === "name") return predefinedCMapIsVertical(encoding.name);
+	if (encoding?.kind === "stream") return asNumber(dictGet(encoding.dict, "WMode")) === VERTICAL_WRITING_MODE;
+	return false;
+}
 function buildCompositeFont(fontDict, context) {
 	const baseFont = asName(dictGet(fontDict, "BaseFont")) ?? "Helvetica";
 	const descendants = asArray(dictGet(fontDict, "DescendantFonts"));
@@ -185,9 +242,22 @@ function buildCompositeFont(fontDict, context) {
 	const dw = descendantDict !== void 0 ? asNumber(dictGet(descendantDict, "DW")) ?? DEFAULT_CID_WIDTH : DEFAULT_CID_WIDTH;
 	const widthMap = readCidWidths(descendantDict !== void 0 ? asArray(dictGet(descendantDict, "W")) : void 0);
 	const widthOf = (cid) => widthMap.get(cid) ?? dw;
+	const dw2 = descendantDict !== void 0 ? asArray(dictGet(descendantDict, "DW2")) : void 0;
+	const defaultPositionY = (dw2?.length === DW2_ENTRY_COUNT ? asNumber(dw2[0]) : void 0) ?? DEFAULT_VERTICAL_POSITION_Y;
+	const defaultDisplacementY = (dw2?.length === DW2_ENTRY_COUNT ? asNumber(dw2[1]) : void 0) ?? DEFAULT_VERTICAL_DISPLACEMENT_Y;
+	const verticalMap = readCidVerticalMetrics(descendantDict !== void 0 ? asArray(dictGet(descendantDict, "W2")) : void 0);
+	const verticalMetricsOf = (cid) => {
+		const entry = verticalMap.get(cid);
+		return {
+			displacementY: entry?.displacementY ?? defaultDisplacementY,
+			positionX: entry?.positionX ?? widthOf(cid) / 2,
+			positionY: entry?.positionY ?? defaultPositionY
+		};
+	};
 	const toUnicode = readToUnicodeCMap(fontDict, context);
 	const cidToGidMap = descendantDict !== void 0 ? dictGet(descendantDict, "CIDToGIDMap") : void 0;
-	const programEncoding = isName(dictGet(fontDict, "Encoding"), "Identity-H") && (cidToGidMap === void 0 || isName(cidToGidMap, "Identity")) ? lazyFontProgram(descriptor, context) : void 0;
+	const encodingName = dictGet(fontDict, "Encoding");
+	const programEncoding = (isName(encodingName, "Identity-H") || isName(encodingName, "Identity-V")) && (cidToGidMap === void 0 || isName(cidToGidMap, "Identity")) ? lazyFontProgram(descriptor, context) : void 0;
 	const decodeToUnicode = (codes) => {
 		let out = "";
 		let glyphCount = 0;
@@ -221,7 +291,8 @@ function buildCompositeFont(fontDict, context) {
 		bold,
 		italic,
 		widthOf,
-		decodeToUnicode
+		decodeToUnicode,
+		...readsVertically(fontDict, context) ? { verticalMetricsOf } : {}
 	};
 }
 function createFontResolver(context) {
@@ -236,16 +307,27 @@ function createFontResolver(context) {
 		return resolved;
 	};
 	return {
-		metrics: { glyphAdvance(fontResourceName, resources, codes, byteOffset) {
-			const font = resolve(fontResourceName, resources);
-			if (font === void 0) return;
-			const byteLengthConsumed = font.composite ? 2 : 1;
-			const code = font.composite ? (codes[byteOffset] ?? 0) << 8 | (codes[byteOffset + 1] ?? 0) : codes[byteOffset] ?? 0;
-			return {
-				widthPer1000: font.widthOf(code),
-				byteLengthConsumed
-			};
-		} },
+		metrics: {
+			glyphAdvance(fontResourceName, resources, codes, byteOffset) {
+				const font = resolve(fontResourceName, resources);
+				if (font === void 0) return;
+				const byteLengthConsumed = font.composite ? 2 : 1;
+				const code = font.composite ? (codes[byteOffset] ?? 0) << 8 | (codes[byteOffset + 1] ?? 0) : codes[byteOffset] ?? 0;
+				const vertical = font.verticalMetricsOf?.(code);
+				return {
+					widthPer1000: font.widthOf(code),
+					byteLengthConsumed,
+					...vertical === void 0 ? {} : { vertical: {
+						displacementPer1000: vertical.displacementY,
+						positionXPer1000: vertical.positionX,
+						positionYPer1000: vertical.positionY
+					} }
+				};
+			},
+			isVertical(fontResourceName, resources) {
+				return resolve(fontResourceName, resources)?.verticalMetricsOf !== void 0;
+			}
+		},
 		resolve
 	};
 }

package/dist/interpret.cjs

@@ -433,24 +433,38 @@ function runContentStream(bytes, resources, initialState, context, items, depth,
 			const widthPer1000 = glyph?.widthPer1000 ?? FALLBACK_GLYPH_WIDTH_PER_1000;
 			const byteLength = glyph?.byteLengthConsumed ?? 1;
 			const isSingleByteSpace = byteLength === 1 && codes[offset] === 32;
-			const tx = (widthPer1000 / 1e3 * gs.fontSizePt + gs.charSpace + (isSingleByteSpace ? gs.wordSpace : 0)) * gs.horizScale;
-			text.tm = require_matrix.multiplyMatrices(require_matrix.translationMatrix(tx, 0), text.tm);
+			const spacing = gs.charSpace + (isSingleByteSpace ? gs.wordSpace : 0);
+			const vertical = glyph?.vertical;
+			text.tm = vertical === void 0 ? require_matrix.multiplyMatrices(require_matrix.translationMatrix((widthPer1000 / 1e3 * gs.fontSizePt + spacing) * gs.horizScale, 0), text.tm) : require_matrix.multiplyMatrices(require_matrix.translationMatrix(0, vertical.displacementPer1000 / 1e3 * gs.fontSizePt + spacing), text.tm);
 			offset += byteLength;
 		}
 	};
+	const positionVectorOf = (codes) => {
+		const fontResourceName = gs.fontResourceName;
+		if (fontResourceName === void 0) return;
+		const vertical = context.fontMetrics.glyphAdvance(fontResourceName, resources, codes, 0)?.vertical;
+		if (vertical === void 0) return;
+		return {
+			x: vertical.positionXPer1000 / 1e3,
+			y: vertical.positionYPer1000 / 1e3
+		};
+	};
 	const showTextArray = (elements) => {
 		const fontResourceName = gs.fontResourceName;
 		if (fontResourceName === void 0) return;
+		const vertical = context.fontMetrics.isVertical(fontResourceName, resources);
 		const startMatrix = computeTrm(gs, text);
 		const chunks = [];
 		let totalLength = 0;
+		let firstGlyphPosition;
 		for (const el of elements) if (el.kind === "string") {
+			firstGlyphPosition ??= vertical ? positionVectorOf(el.bytes) : void 0;
 			chunks.push(el.bytes);
 			totalLength += el.bytes.length;
 			advanceThroughString(el.bytes);
 		} else if (el.kind === "number") {
-			const adjustment = -(el.value / 1e3) * gs.fontSizePt * gs.horizScale;
-			text.tm = require_matrix.multiplyMatrices(require_matrix.translationMatrix(adjustment, 0), text.tm);
+			const adjustment = -(el.value / 1e3) * gs.fontSizePt;
+			text.tm = require_matrix.multiplyMatrices(vertical ? require_matrix.translationMatrix(0, adjustment) : require_matrix.translationMatrix(adjustment * gs.horizScale, 0), text.tm);
 		}
 		if (totalLength === 0) return;
 		const combined = new Uint8Array(totalLength);
@@ -460,15 +474,17 @@ function runContentStream(bytes, resources, initialState, context, items, depth,
 			at += chunk.length;
 		}
 		const endMatrix = computeTrm(gs, text);
+		const shift = firstGlyphPosition === void 0 ? void 0 : require_matrix.translationMatrix(-firstGlyphPosition.x, -firstGlyphPosition.y);
 		pushItem({
 			kind: "text",
 			codes: combined,
 			fontResourceName,
 			resources,
-			startMatrix,
-			endMatrix,
+			startMatrix: shift === void 0 ? startMatrix : require_matrix.multiplyMatrices(shift, startMatrix),
+			endMatrix: shift === void 0 ? endMatrix : require_matrix.multiplyMatrices(shift, endMatrix),
 			sizePt: gs.fontSizePt,
-			color: gs.fillColor
+			color: gs.fillColor,
+			...vertical ? { vertical: true } : {}
 		});
 	};
 	const showText = (bytes) => {

package/dist/interpret.d.cts

@@ -16,6 +16,7 @@ interface ExtractedTextRun {
   readonly actualText?: string;
   readonly alt?: string;
   readonly mcid?: number;
+  readonly vertical?: boolean;
 }
 interface ExtractedPaint {
   readonly fill: Color | undefined;
@@ -94,12 +95,19 @@ interface ExtractedInlineImage {
   readonly mcid?: number;
 }
 type ExtractedItem = ExtractedTextRun | ExtractedRect | ExtractedEllipse | ExtractedLine | ExtractedPath | ExtractedImage | ExtractedInlineImage;
+interface VerticalGlyphAdvance {
+  readonly displacementPer1000: number;
+  readonly positionXPer1000: number;
+  readonly positionYPer1000: number;
+}
 interface GlyphAdvance {
   readonly widthPer1000: number;
   readonly byteLengthConsumed: number;
+  readonly vertical?: VerticalGlyphAdvance;
 }
 interface FontMetricsPort {
   glyphAdvance(fontResourceName: string, resources: PdfDict, codes: Uint8Array<ArrayBuffer>, byteOffset: number): GlyphAdvance | undefined;
+  isVertical(fontResourceName: string, resources: PdfDict): boolean;
 }
 interface PdfObjectResolver {
   resolve(obj: PdfObject | undefined): PdfObject | undefined;
@@ -113,4 +121,4 @@ interface InterpretContext {
 }
 declare function interpretContentStream(bytes: Uint8Array<ArrayBuffer>, resources: PdfDict, context: InterpretContext): ExtractedItem[];
 //#endregion
-export { ExtractedEllipse, ExtractedImage, ExtractedInlineImage, ExtractedItem, ExtractedLine, ExtractedPaint, ExtractedPath, ExtractedPathSegment, ExtractedRect, ExtractedSubpath, ExtractedTextRun, FontMetricsPort, GlyphAdvance, InterpretContext, PdfObjectResolver, interpretContentStream };
+export { ExtractedEllipse, ExtractedImage, ExtractedInlineImage, ExtractedItem, ExtractedLine, ExtractedPaint, ExtractedPath, ExtractedPathSegment, ExtractedRect, ExtractedSubpath, ExtractedTextRun, FontMetricsPort, GlyphAdvance, InterpretContext, PdfObjectResolver, VerticalGlyphAdvance, interpretContentStream };

package/dist/interpret.d.ts

@@ -16,6 +16,7 @@ interface ExtractedTextRun {
   readonly actualText?: string;
   readonly alt?: string;
   readonly mcid?: number;
+  readonly vertical?: boolean;
 }
 interface ExtractedPaint {
   readonly fill: Color | undefined;
@@ -94,12 +95,19 @@ interface ExtractedInlineImage {
   readonly mcid?: number;
 }
 type ExtractedItem = ExtractedTextRun | ExtractedRect | ExtractedEllipse | ExtractedLine | ExtractedPath | ExtractedImage | ExtractedInlineImage;
+interface VerticalGlyphAdvance {
+  readonly displacementPer1000: number;
+  readonly positionXPer1000: number;
+  readonly positionYPer1000: number;
+}
 interface GlyphAdvance {
   readonly widthPer1000: number;
   readonly byteLengthConsumed: number;
+  readonly vertical?: VerticalGlyphAdvance;
 }
 interface FontMetricsPort {
   glyphAdvance(fontResourceName: string, resources: PdfDict, codes: Uint8Array<ArrayBuffer>, byteOffset: number): GlyphAdvance | undefined;
+  isVertical(fontResourceName: string, resources: PdfDict): boolean;
 }
 interface PdfObjectResolver {
   resolve(obj: PdfObject | undefined): PdfObject | undefined;
@@ -113,4 +121,4 @@ interface InterpretContext {
 }
 declare function interpretContentStream(bytes: Uint8Array<ArrayBuffer>, resources: PdfDict, context: InterpretContext): ExtractedItem[];
 //#endregion
-export { ExtractedEllipse, ExtractedImage, ExtractedInlineImage, ExtractedItem, ExtractedLine, ExtractedPaint, ExtractedPath, ExtractedPathSegment, ExtractedRect, ExtractedSubpath, ExtractedTextRun, FontMetricsPort, GlyphAdvance, InterpretContext, PdfObjectResolver, interpretContentStream };
+export { ExtractedEllipse, ExtractedImage, ExtractedInlineImage, ExtractedItem, ExtractedLine, ExtractedPaint, ExtractedPath, ExtractedPathSegment, ExtractedRect, ExtractedSubpath, ExtractedTextRun, FontMetricsPort, GlyphAdvance, InterpretContext, PdfObjectResolver, VerticalGlyphAdvance, interpretContentStream };

package/dist/interpret.js

@@ -432,24 +432,38 @@ function runContentStream(bytes, resources, initialState, context, items, depth,
 			const widthPer1000 = glyph?.widthPer1000 ?? FALLBACK_GLYPH_WIDTH_PER_1000;
 			const byteLength = glyph?.byteLengthConsumed ?? 1;
 			const isSingleByteSpace = byteLength === 1 && codes[offset] === 32;
-			const tx = (widthPer1000 / 1e3 * gs.fontSizePt + gs.charSpace + (isSingleByteSpace ? gs.wordSpace : 0)) * gs.horizScale;
-			text.tm = multiplyMatrices(translationMatrix(tx, 0), text.tm);
+			const spacing = gs.charSpace + (isSingleByteSpace ? gs.wordSpace : 0);
+			const vertical = glyph?.vertical;
+			text.tm = vertical === void 0 ? multiplyMatrices(translationMatrix((widthPer1000 / 1e3 * gs.fontSizePt + spacing) * gs.horizScale, 0), text.tm) : multiplyMatrices(translationMatrix(0, vertical.displacementPer1000 / 1e3 * gs.fontSizePt + spacing), text.tm);
 			offset += byteLength;
 		}
 	};
+	const positionVectorOf = (codes) => {
+		const fontResourceName = gs.fontResourceName;
+		if (fontResourceName === void 0) return;
+		const vertical = context.fontMetrics.glyphAdvance(fontResourceName, resources, codes, 0)?.vertical;
+		if (vertical === void 0) return;
+		return {
+			x: vertical.positionXPer1000 / 1e3,
+			y: vertical.positionYPer1000 / 1e3
+		};
+	};
 	const showTextArray = (elements) => {
 		const fontResourceName = gs.fontResourceName;
 		if (fontResourceName === void 0) return;
+		const vertical = context.fontMetrics.isVertical(fontResourceName, resources);
 		const startMatrix = computeTrm(gs, text);
 		const chunks = [];
 		let totalLength = 0;
+		let firstGlyphPosition;
 		for (const el of elements) if (el.kind === "string") {
+			firstGlyphPosition ??= vertical ? positionVectorOf(el.bytes) : void 0;
 			chunks.push(el.bytes);
 			totalLength += el.bytes.length;
 			advanceThroughString(el.bytes);
 		} else if (el.kind === "number") {
-			const adjustment = -(el.value / 1e3) * gs.fontSizePt * gs.horizScale;
-			text.tm = multiplyMatrices(translationMatrix(adjustment, 0), text.tm);
+			const adjustment = -(el.value / 1e3) * gs.fontSizePt;
+			text.tm = multiplyMatrices(vertical ? translationMatrix(0, adjustment) : translationMatrix(adjustment * gs.horizScale, 0), text.tm);
 		}
 		if (totalLength === 0) return;
 		const combined = new Uint8Array(totalLength);
@@ -459,15 +473,17 @@ function runContentStream(bytes, resources, initialState, context, items, depth,
 			at += chunk.length;
 		}
 		const endMatrix = computeTrm(gs, text);
+		const shift = firstGlyphPosition === void 0 ? void 0 : translationMatrix(-firstGlyphPosition.x, -firstGlyphPosition.y);
 		pushItem({
 			kind: "text",
 			codes: combined,
 			fontResourceName,
 			resources,
-			startMatrix,
-			endMatrix,
+			startMatrix: shift === void 0 ? startMatrix : multiplyMatrices(shift, startMatrix),
+			endMatrix: shift === void 0 ? endMatrix : multiplyMatrices(shift, endMatrix),
 			sizePt: gs.fontSizePt,
-			color: gs.fillColor
+			color: gs.fillColor,
+			...vertical ? { vertical: true } : {}
 		});
 	};
 	const showText = (bytes) => {

package/dist/layout.cjs

@@ -13,6 +13,7 @@ const LayoutTextSchema = zod.z.object({
 	color: document_schema_js.ColorSchema,
 	widthPt: zod.z.number().nonnegative().optional(),
 	rotationDeg: zod.z.number().optional(),
+	writingMode: zod.z.literal("vertical").optional(),
 	underline: zod.z.boolean().optional(),
 	layer: zod.z.string().optional(),
 	actualText: zod.z.string().optional(),

package/dist/layout.d.cts

@@ -25,6 +25,7 @@ declare const LayoutTextSchema: z.ZodObject<{
   }, z.core.$strip>;
   widthPt: z.ZodOptional<z.ZodNumber>;
   rotationDeg: z.ZodOptional<z.ZodNumber>;
+  writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
   underline: z.ZodOptional<z.ZodBoolean>;
   layer: z.ZodOptional<z.ZodString>;
   actualText: z.ZodOptional<z.ZodString>;
@@ -243,6 +244,7 @@ declare const LayoutItemSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strip>;
   widthPt: z.ZodOptional<z.ZodNumber>;
   rotationDeg: z.ZodOptional<z.ZodNumber>;
+  writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
   underline: z.ZodOptional<z.ZodBoolean>;
   layer: z.ZodOptional<z.ZodString>;
   actualText: z.ZodOptional<z.ZodString>;
@@ -475,6 +477,7 @@ declare const LayoutPageSchema: z.ZodObject<{
     }, z.core.$strip>;
     widthPt: z.ZodOptional<z.ZodNumber>;
     rotationDeg: z.ZodOptional<z.ZodNumber>;
+    writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
     underline: z.ZodOptional<z.ZodBoolean>;
     layer: z.ZodOptional<z.ZodString>;
     actualText: z.ZodOptional<z.ZodString>;
@@ -825,6 +828,7 @@ declare const LayoutDocumentSchema: z.ZodObject<{
       }, z.core.$strip>;
       widthPt: z.ZodOptional<z.ZodNumber>;
       rotationDeg: z.ZodOptional<z.ZodNumber>;
+      writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
       underline: z.ZodOptional<z.ZodBoolean>;
       layer: z.ZodOptional<z.ZodString>;
       actualText: z.ZodOptional<z.ZodString>;

package/dist/layout.d.ts

@@ -25,6 +25,7 @@ declare const LayoutTextSchema: z.ZodObject<{
   }, z.core.$strip>;
   widthPt: z.ZodOptional<z.ZodNumber>;
   rotationDeg: z.ZodOptional<z.ZodNumber>;
+  writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
   underline: z.ZodOptional<z.ZodBoolean>;
   layer: z.ZodOptional<z.ZodString>;
   actualText: z.ZodOptional<z.ZodString>;
@@ -243,6 +244,7 @@ declare const LayoutItemSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strip>;
   widthPt: z.ZodOptional<z.ZodNumber>;
   rotationDeg: z.ZodOptional<z.ZodNumber>;
+  writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
   underline: z.ZodOptional<z.ZodBoolean>;
   layer: z.ZodOptional<z.ZodString>;
   actualText: z.ZodOptional<z.ZodString>;
@@ -475,6 +477,7 @@ declare const LayoutPageSchema: z.ZodObject<{
     }, z.core.$strip>;
     widthPt: z.ZodOptional<z.ZodNumber>;
     rotationDeg: z.ZodOptional<z.ZodNumber>;
+    writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
     underline: z.ZodOptional<z.ZodBoolean>;
     layer: z.ZodOptional<z.ZodString>;
     actualText: z.ZodOptional<z.ZodString>;
@@ -825,6 +828,7 @@ declare const LayoutDocumentSchema: z.ZodObject<{
       }, z.core.$strip>;
       widthPt: z.ZodOptional<z.ZodNumber>;
       rotationDeg: z.ZodOptional<z.ZodNumber>;
+      writingMode: z.ZodOptional<z.ZodLiteral<"vertical">>;
       underline: z.ZodOptional<z.ZodBoolean>;
       layer: z.ZodOptional<z.ZodString>;
       actualText: z.ZodOptional<z.ZodString>;

package/dist/layout.js

@@ -12,6 +12,7 @@ const LayoutTextSchema = z.object({
 	color: ColorSchema,
 	widthPt: z.number().nonnegative().optional(),
 	rotationDeg: z.number().optional(),
+	writingMode: z.literal("vertical").optional(),
 	underline: z.boolean().optional(),
 	layer: z.string().optional(),
 	actualText: z.string().optional(),

package/dist/raster.cjs

@@ -533,8 +533,8 @@ function buildTextOutlineFace(fontDict, resolver, fontResolver, fontResourceName
 	const subtype = require_objects.asName(require_objects.dictGet(fontDict, "Subtype"));
 	if (subtype === "Type0") {
 		const encoding = resolver.resolve(require_objects.dictGet(fontDict, "Encoding"));
-		if (encoding?.kind !== "name" || encoding.name !== "Identity-H") {
-			unavailable("a Type0 font whose /Encoding is not Identity-H (a predefined or embedded CMap this raster walk does not decode)");
+		if (encoding?.kind !== "name" || encoding.name !== "Identity-H" && encoding.name !== "Identity-V") {
+			unavailable("a Type0 font whose /Encoding is neither Identity-H nor Identity-V (a predefined or embedded CMap this raster walk does not decode)");
 			return;
 		}
 		const descendants = require_objects.asArray(require_objects.dictGet(fontDict, "DescendantFonts"));
@@ -623,17 +623,19 @@ function drawTextRun(item, fontResolver, resolver, outlineFaces, interpretToDevi
 	let cumulative = 0;
 	while (offset < item.codes.length) {
 		const advance = fontResolver.metrics.glyphAdvance(item.fontResourceName, item.resources, item.codes, offset);
-		const widthPer1000 = advance.widthPer1000;
 		const byteLength = advance.byteLengthConsumed;
 		placements.push({
 			glyphId: face.glyphIdOf(item.codes, offset),
-			advance: cumulative
+			advance: cumulative,
+			positionX: (advance.vertical?.positionXPer1000 ?? 0) / 1e3,
+			positionY: (advance.vertical?.positionYPer1000 ?? 0) / 1e3
 		});
-		cumulative += widthPer1000 / 1e3 * item.sizePt;
+		cumulative += (advance.vertical?.displacementPer1000 ?? advance.widthPer1000) / 1e3 * item.sizePt;
 		offset += byteLength;
 	}
 	const startDeviceMatrix = require_matrix.multiplyMatrices(item.startMatrix, interpretToDeviceMatrix);
 	const endDeviceMatrix = require_matrix.multiplyMatrices(item.endMatrix, interpretToDeviceMatrix);
+	const vertical = item.vertical === true;
 	const startPoint = require_matrix.applyMatrix(startDeviceMatrix, {
 		x: 0,
 		y: 0
@@ -642,19 +644,23 @@ function drawTextRun(item, fontResolver, resolver, outlineFaces, interpretToDevi
 		x: 0,
 		y: 0
 	});
-	const rawEndPoint = require_matrix.applyMatrix(startDeviceMatrix, {
+	const rawEndPoint = require_matrix.applyMatrix(startDeviceMatrix, vertical ? {
+		x: 0,
+		y: cumulative
+	} : {
 		x: cumulative,
 		y: 0
 	});
 	const rawExtent = Math.hypot(rawEndPoint.x - startPoint.x, rawEndPoint.y - startPoint.y);
 	const actualExtent = Math.hypot(endPoint.x - startPoint.x, endPoint.y - startPoint.y);
-	const correction = rawExtent > 1e-9 && cumulative > 0 ? actualExtent / rawExtent : 1;
+	const correction = rawExtent > 1e-9 ? actualExtent / rawExtent : 1;
+	const firstPlacement = placements[0];
 	const glyphScale = require_matrix.scaleMatrix(1 / face.unitsPerEm, 1 / face.unitsPerEm);
 	for (const placement of placements) {
 		if (placement.glyphId === void 0) continue;
 		const outline = require_glyf_contours.decodeGlyphOutline(face.glyf, placement.glyphId);
 		if (outline === void 0) continue;
-		const trm = require_matrix.multiplyMatrices(require_matrix.translationMatrix(placement.advance * correction, 0), item.startMatrix);
+		const trm = require_matrix.multiplyMatrices(require_matrix.translationMatrix((firstPlacement?.positionX ?? 0) - placement.positionX, (firstPlacement?.positionY ?? 0) - placement.positionY), require_matrix.multiplyMatrices(vertical ? require_matrix.translationMatrix(0, placement.advance * correction) : require_matrix.translationMatrix(placement.advance * correction, 0), item.startMatrix));
 		drawGlyphOutline(outline, require_matrix.multiplyMatrices(glyphScale, require_matrix.multiplyMatrices(trm, interpretToDeviceMatrix)), item.color, rasteriser);
 	}
 }

package/dist/raster.js

@@ -532,8 +532,8 @@ function buildTextOutlineFace(fontDict, resolver, fontResolver, fontResourceName
 	const subtype = asName(dictGet(fontDict, "Subtype"));
 	if (subtype === "Type0") {
 		const encoding = resolver.resolve(dictGet(fontDict, "Encoding"));
-		if (encoding?.kind !== "name" || encoding.name !== "Identity-H") {
-			unavailable("a Type0 font whose /Encoding is not Identity-H (a predefined or embedded CMap this raster walk does not decode)");
+		if (encoding?.kind !== "name" || encoding.name !== "Identity-H" && encoding.name !== "Identity-V") {
+			unavailable("a Type0 font whose /Encoding is neither Identity-H nor Identity-V (a predefined or embedded CMap this raster walk does not decode)");
 			return;
 		}
 		const descendants = asArray(dictGet(fontDict, "DescendantFonts"));
@@ -622,17 +622,19 @@ function drawTextRun(item, fontResolver, resolver, outlineFaces, interpretToDevi
 	let cumulative = 0;
 	while (offset < item.codes.length) {
 		const advance = fontResolver.metrics.glyphAdvance(item.fontResourceName, item.resources, item.codes, offset);
-		const widthPer1000 = advance.widthPer1000;
 		const byteLength = advance.byteLengthConsumed;
 		placements.push({
 			glyphId: face.glyphIdOf(item.codes, offset),
-			advance: cumulative
+			advance: cumulative,
+			positionX: (advance.vertical?.positionXPer1000 ?? 0) / 1e3,
+			positionY: (advance.vertical?.positionYPer1000 ?? 0) / 1e3
 		});
-		cumulative += widthPer1000 / 1e3 * item.sizePt;
+		cumulative += (advance.vertical?.displacementPer1000 ?? advance.widthPer1000) / 1e3 * item.sizePt;
 		offset += byteLength;
 	}
 	const startDeviceMatrix = multiplyMatrices(item.startMatrix, interpretToDeviceMatrix);
 	const endDeviceMatrix = multiplyMatrices(item.endMatrix, interpretToDeviceMatrix);
+	const vertical = item.vertical === true;
 	const startPoint = applyMatrix(startDeviceMatrix, {
 		x: 0,
 		y: 0
@@ -641,19 +643,23 @@ function drawTextRun(item, fontResolver, resolver, outlineFaces, interpretToDevi
 		x: 0,
 		y: 0
 	});
-	const rawEndPoint = applyMatrix(startDeviceMatrix, {
+	const rawEndPoint = applyMatrix(startDeviceMatrix, vertical ? {
+		x: 0,
+		y: cumulative
+	} : {
 		x: cumulative,
 		y: 0
 	});
 	const rawExtent = Math.hypot(rawEndPoint.x - startPoint.x, rawEndPoint.y - startPoint.y);
 	const actualExtent = Math.hypot(endPoint.x - startPoint.x, endPoint.y - startPoint.y);
-	const correction = rawExtent > 1e-9 && cumulative > 0 ? actualExtent / rawExtent : 1;
+	const correction = rawExtent > 1e-9 ? actualExtent / rawExtent : 1;
+	const firstPlacement = placements[0];
 	const glyphScale = scaleMatrix(1 / face.unitsPerEm, 1 / face.unitsPerEm);
 	for (const placement of placements) {
 		if (placement.glyphId === void 0) continue;
 		const outline = decodeGlyphOutline(face.glyf, placement.glyphId);
 		if (outline === void 0) continue;
-		const trm = multiplyMatrices(translationMatrix(placement.advance * correction, 0), item.startMatrix);
+		const trm = multiplyMatrices(translationMatrix((firstPlacement?.positionX ?? 0) - placement.positionX, (firstPlacement?.positionY ?? 0) - placement.positionY), multiplyMatrices(vertical ? translationMatrix(0, placement.advance * correction) : translationMatrix(placement.advance * correction, 0), item.startMatrix));
 		drawGlyphOutline(outline, multiplyMatrices(glyphScale, multiplyMatrices(trm, interpretToDeviceMatrix)), item.color, rasteriser);
 	}
 }

package/dist/read.cjs

@@ -366,6 +366,7 @@ function convertText(item, pageMatrix, fontResolver) {
 		color: item.color,
 		widthPt,
 		rotationDeg: rotationDeg !== 0 ? rotationDeg : void 0,
+		...item.vertical === true ? { writingMode: "vertical" } : {},
 		...item.layerName !== void 0 ? { layer: item.layerName } : {},
 		...item.actualText !== void 0 ? { actualText: item.actualText } : {},
 		...item.alt !== void 0 ? { alt: item.alt } : {}

package/dist/read.js

@@ -365,6 +365,7 @@ function convertText(item, pageMatrix, fontResolver) {
 		color: item.color,
 		widthPt,
 		rotationDeg: rotationDeg !== 0 ? rotationDeg : void 0,
+		...item.vertical === true ? { writingMode: "vertical" } : {},
 		...item.layerName !== void 0 ? { layer: item.layerName } : {},
 		...item.actualText !== void 0 ? { actualText: item.actualText } : {},
 		...item.alt !== void 0 ? { alt: item.alt } : {}

package/dist/text-group.cjs

@@ -5,8 +5,10 @@ const DEFAULT_WORD_GAP_EM = 1 / 8;
 const DEFAULT_COLUMN_GAP_EM = 1;
 const ROTATION_NOISE_DEG = 1e-6;
 const DEGREES_PER_TURN = 360;
-function normaliseRotationDeg(rotationDeg) {
-	return (Math.round((rotationDeg ?? 0) / ROTATION_NOISE_DEG) * ROTATION_NOISE_DEG % DEGREES_PER_TURN + DEGREES_PER_TURN) % DEGREES_PER_TURN;
+const VERTICAL_ADVANCE_OFFSET_DEG = -90;
+function advanceAngleDeg(run) {
+	const raw = (run.rotationDeg ?? 0) + (run.writingMode === "vertical" ? VERTICAL_ADVANCE_OFFSET_DEG : 0);
+	return (Math.round(raw / ROTATION_NOISE_DEG) * ROTATION_NOISE_DEG % DEGREES_PER_TURN + DEGREES_PER_TURN) % DEGREES_PER_TURN;
 }
 const RADIANS_PER_TURN = 2 * Math.PI;
 function baselineAxis(rotationDeg) {
@@ -42,8 +44,8 @@ function unproject(alongPt, acrossPt, rotationDeg) {
 * @returns true when the two baselines are within tolerance of each other
 */
 function runsShareBaseline(a, b, options = {}) {
-	const rotationDeg = normaliseRotationDeg(a.rotationDeg);
-	if (rotationDeg !== normaliseRotationDeg(b.rotationDeg)) return false;
+	const rotationDeg = advanceAngleDeg(a);
+	if (rotationDeg !== advanceAngleDeg(b) || a.writingMode !== b.writingMode) return false;
 	const toleranceEm = options.baselineToleranceEm ?? .6666666666666666;
 	return Math.abs(project(a, rotationDeg).acrossPt - project(b, rotationDeg).acrossPt) <= toleranceEm * Math.min(a.sizePt, b.sizePt);
 }
@@ -56,8 +58,8 @@ function runsShareBaseline(a, b, options = {}) {
 * @returns the gap in points, or undefined when it cannot be derived
 */
 function runGapPt(previous, next) {
-	const rotationDeg = normaliseRotationDeg(previous.rotationDeg);
-	if (rotationDeg !== normaliseRotationDeg(next.rotationDeg)) return;
+	const rotationDeg = advanceAngleDeg(previous);
+	if (rotationDeg !== advanceAngleDeg(next) || previous.writingMode !== next.writingMode) return;
 	const previousWidthPt = previous.widthPt;
 	if (previousWidthPt === void 0) return;
 	return project(next, rotationDeg).alongPt - (project(previous, rotationDeg).alongPt + previousWidthPt);
@@ -150,7 +152,7 @@ function buildWords(line, rotationDeg, wordGapEm, columnGapEm) {
 		...word.measurable ? { bounds: boundsOf(word.minAlongPt, word.maxAlongEndPt, line.anchor.acrossPt, word.maxSizePt, rotationDeg) } : {}
 	}));
 }
-function buildLine(line, rotationDeg, wordGapEm, columnGapEm) {
+function buildLine(line, rotationDeg, vertical, wordGapEm, columnGapEm) {
 	const words = buildWords(line, rotationDeg, wordGapEm, columnGapEm);
 	const text = words.map((word) => SEPARATOR_TEXT[word.separatorBefore] + word.text).join("");
 	let minAlongPt = Number.POSITIVE_INFINITY;
@@ -169,6 +171,7 @@ function buildLine(line, rotationDeg, wordGapEm, columnGapEm) {
 		words,
 		baselineYPt: line.anchor.acrossPt,
 		rotationDeg,
+		...vertical ? { writingMode: "vertical" } : {},
 		...measurable ? { bounds: boundsOf(minAlongPt, maxAlongEndPt, line.anchor.acrossPt, maxSizePt, rotationDeg) } : {}
 	};
 }
@@ -181,7 +184,7 @@ function buildLine(line, rotationDeg, wordGapEm, columnGapEm) {
 *
 * Grouping is by baseline alone, with no page segmentation: on a multi-column page whose columns are set at different vertical offsets, a line of one column can fall within tolerance of a line of the next and the two are reported as one line, because from geometry alone at this level that is what they are. The gutter between them still reads as a column boundary, so the separator says where to cut. A caller that needs the columns apart segments the page first, which is what document-outline.js's `segmentPdfRegions` is for, and groups each region's own runs.
 *
-* Known limitations, all of them inherent to what a PDF states rather than to this implementation. Text is reported in visual order, left to right along the baseline: a right-to-left script arrives from the content stream already laid out visually and carries no direction of its own, so a consumer needing logical order applies the Unicode Bidi Algorithm to the result. Vertical writing modes are not recognised, because this package's content interpreter does not read a CMap's WMode and so reports vertically set text with horizontal advances (ExaDev/documents.js#1358), which puts the positions beyond anything grouping could repair. A word hyphenated across a line end is left split, with its hyphen intact, because rejoining it needs to know the two lines belong to one paragraph, which is a semantic judgement this package deliberately leaves to its consumers. Runs with empty text are dropped, and so are the empty words a whitespace-only run would otherwise produce, but no other normalisation of the decoded text is attempted: a ligature and a zero-width character each reach the output exactly as the font's ToUnicode mapping spelled them.
+* Known limitations, all of them inherent to what a PDF states rather than to this implementation. Text is reported in visual order, left to right along the baseline: a right-to-left script arrives from the content stream already laid out visually and carries no direction of its own, so a consumer needing logical order applies the Unicode Bidi Algorithm to the result. A vertically set run is grouped into columns rather than lines, from the writingMode its own reader reported, and its column is reported with a rotationDeg of 270 and its own writingMode; columns order right to left, the direction vertical setting is read in. What is NOT recognised is a predefined non-Identity CMap's own byte decoding, so a vertically set font using one (90ms-RKSJ-V and its siblings) still has its codes read as two-byte CIDs, which is this package's own long-standing composite-font limit rather than anything about writing mode. A word hyphenated across a line end is left split, with its hyphen intact, because rejoining it needs to know the two lines belong to one paragraph, which is a semantic judgement this package deliberately leaves to its consumers. Runs with empty text are dropped, and so are the empty words a whitespace-only run would otherwise produce, but no other normalisation of the decoded text is attempted: a ligature and a zero-width character each reach the output exactly as the font's ToUnicode mapping spelled them.
 * @param runs - positioned text runs, in any order
 * @param options - tolerance overrides; each defaults to the exported constant of the same name
 * @returns the grouped lines, in reading order
@@ -190,20 +193,27 @@ function groupPdfTextRuns(runs, options = {}) {
 	const toleranceEm = options.baselineToleranceEm ?? .6666666666666666;
 	const wordGapEm = options.wordGapEm ?? .125;
 	const columnGapEm = options.columnGapEm ?? 1;
-	const byRotation = /* @__PURE__ */ new Map();
+	const buckets = /* @__PURE__ */ new Map();
 	for (const run of runs) {
 		if (run.text.length === 0) continue;
-		const rotationDeg = normaliseRotationDeg(run.rotationDeg);
-		const bucket = byRotation.get(rotationDeg);
-		if (bucket === void 0) byRotation.set(rotationDeg, [run]);
-		else bucket.push(run);
+		const rotationDeg = advanceAngleDeg(run);
+		const vertical = run.writingMode === "vertical";
+		const key = `${String(rotationDeg)}|${String(vertical)}`;
+		const bucket = buckets.get(key);
+		if (bucket === void 0) buckets.set(key, {
+			rotationDeg,
+			vertical,
+			runs: [run]
+		});
+		else bucket.runs.push(run);
 	}
 	const result = [];
-	for (const rotationDeg of [...byRotation.keys()].sort((a, b) => a - b)) {
-		const entries = (byRotation.get(rotationDeg) ?? []).map((run) => project(run, rotationDeg)).sort((a, b) => b.acrossPt - a.acrossPt || a.alongPt - b.alongPt);
+	const ordered = [...buckets.values()].sort((a, b) => a.rotationDeg - b.rotationDeg || Number(a.vertical) - Number(b.vertical));
+	for (const bucket of ordered) {
+		const entries = bucket.runs.map((run) => project(run, bucket.rotationDeg)).sort((a, b) => b.acrossPt - a.acrossPt || a.alongPt - b.alongPt);
 		for (const line of clusterIntoLines(entries, toleranceEm)) {
 			line.entries.sort((a, b) => a.alongPt - b.alongPt);
-			result.push(buildLine(line, rotationDeg, wordGapEm, columnGapEm));
+			result.push(buildLine(line, bucket.rotationDeg, bucket.vertical, wordGapEm, columnGapEm));
 		}
 	}
 	return result;

package/dist/text-group.d.cts

@@ -6,6 +6,7 @@ interface PdfTextRunGeometry {
   readonly sizePt: number;
   readonly widthPt?: number;
   readonly rotationDeg?: number;
+  readonly writingMode?: "vertical";
 }
 interface PdfTextBox {
   readonly xPt: number;
@@ -25,6 +26,7 @@ interface PdfTextLine<TRun extends PdfTextRunGeometry> {
   readonly words: readonly PdfTextWord<TRun>[];
   readonly baselineYPt: number;
   readonly rotationDeg: number;
+  readonly writingMode?: "vertical";
   readonly bounds?: PdfTextBox;
 }
 interface PdfTextGroupingOptions {
@@ -63,7 +65,7 @@ declare function runGapPt(previous: PdfTextRunGeometry, next: PdfTextRunGeometry
  *
  * Grouping is by baseline alone, with no page segmentation: on a multi-column page whose columns are set at different vertical offsets, a line of one column can fall within tolerance of a line of the next and the two are reported as one line, because from geometry alone at this level that is what they are. The gutter between them still reads as a column boundary, so the separator says where to cut. A caller that needs the columns apart segments the page first, which is what document-outline.js's `segmentPdfRegions` is for, and groups each region's own runs.
  *
- * Known limitations, all of them inherent to what a PDF states rather than to this implementation. Text is reported in visual order, left to right along the baseline: a right-to-left script arrives from the content stream already laid out visually and carries no direction of its own, so a consumer needing logical order applies the Unicode Bidi Algorithm to the result. Vertical writing modes are not recognised, because this package's content interpreter does not read a CMap's WMode and so reports vertically set text with horizontal advances (ExaDev/documents.js#1358), which puts the positions beyond anything grouping could repair. A word hyphenated across a line end is left split, with its hyphen intact, because rejoining it needs to know the two lines belong to one paragraph, which is a semantic judgement this package deliberately leaves to its consumers. Runs with empty text are dropped, and so are the empty words a whitespace-only run would otherwise produce, but no other normalisation of the decoded text is attempted: a ligature and a zero-width character each reach the output exactly as the font's ToUnicode mapping spelled them.
+ * Known limitations, all of them inherent to what a PDF states rather than to this implementation. Text is reported in visual order, left to right along the baseline: a right-to-left script arrives from the content stream already laid out visually and carries no direction of its own, so a consumer needing logical order applies the Unicode Bidi Algorithm to the result. A vertically set run is grouped into columns rather than lines, from the writingMode its own reader reported, and its column is reported with a rotationDeg of 270 and its own writingMode; columns order right to left, the direction vertical setting is read in. What is NOT recognised is a predefined non-Identity CMap's own byte decoding, so a vertically set font using one (90ms-RKSJ-V and its siblings) still has its codes read as two-byte CIDs, which is this package's own long-standing composite-font limit rather than anything about writing mode. A word hyphenated across a line end is left split, with its hyphen intact, because rejoining it needs to know the two lines belong to one paragraph, which is a semantic judgement this package deliberately leaves to its consumers. Runs with empty text are dropped, and so are the empty words a whitespace-only run would otherwise produce, but no other normalisation of the decoded text is attempted: a ligature and a zero-width character each reach the output exactly as the font's ToUnicode mapping spelled them.
  * @param runs - positioned text runs, in any order
  * @param options - tolerance overrides; each defaults to the exported constant of the same name
  * @returns the grouped lines, in reading order

package/dist/text-group.d.ts

@@ -6,6 +6,7 @@ interface PdfTextRunGeometry {
   readonly sizePt: number;
   readonly widthPt?: number;
   readonly rotationDeg?: number;
+  readonly writingMode?: "vertical";
 }
 interface PdfTextBox {
   readonly xPt: number;
@@ -25,6 +26,7 @@ interface PdfTextLine<TRun extends PdfTextRunGeometry> {
   readonly words: readonly PdfTextWord<TRun>[];
   readonly baselineYPt: number;
   readonly rotationDeg: number;
+  readonly writingMode?: "vertical";
   readonly bounds?: PdfTextBox;
 }
 interface PdfTextGroupingOptions {
@@ -63,7 +65,7 @@ declare function runGapPt(previous: PdfTextRunGeometry, next: PdfTextRunGeometry
  *
  * Grouping is by baseline alone, with no page segmentation: on a multi-column page whose columns are set at different vertical offsets, a line of one column can fall within tolerance of a line of the next and the two are reported as one line, because from geometry alone at this level that is what they are. The gutter between them still reads as a column boundary, so the separator says where to cut. A caller that needs the columns apart segments the page first, which is what document-outline.js's `segmentPdfRegions` is for, and groups each region's own runs.
  *
- * Known limitations, all of them inherent to what a PDF states rather than to this implementation. Text is reported in visual order, left to right along the baseline: a right-to-left script arrives from the content stream already laid out visually and carries no direction of its own, so a consumer needing logical order applies the Unicode Bidi Algorithm to the result. Vertical writing modes are not recognised, because this package's content interpreter does not read a CMap's WMode and so reports vertically set text with horizontal advances (ExaDev/documents.js#1358), which puts the positions beyond anything grouping could repair. A word hyphenated across a line end is left split, with its hyphen intact, because rejoining it needs to know the two lines belong to one paragraph, which is a semantic judgement this package deliberately leaves to its consumers. Runs with empty text are dropped, and so are the empty words a whitespace-only run would otherwise produce, but no other normalisation of the decoded text is attempted: a ligature and a zero-width character each reach the output exactly as the font's ToUnicode mapping spelled them.
+ * Known limitations, all of them inherent to what a PDF states rather than to this implementation. Text is reported in visual order, left to right along the baseline: a right-to-left script arrives from the content stream already laid out visually and carries no direction of its own, so a consumer needing logical order applies the Unicode Bidi Algorithm to the result. A vertically set run is grouped into columns rather than lines, from the writingMode its own reader reported, and its column is reported with a rotationDeg of 270 and its own writingMode; columns order right to left, the direction vertical setting is read in. What is NOT recognised is a predefined non-Identity CMap's own byte decoding, so a vertically set font using one (90ms-RKSJ-V and its siblings) still has its codes read as two-byte CIDs, which is this package's own long-standing composite-font limit rather than anything about writing mode. A word hyphenated across a line end is left split, with its hyphen intact, because rejoining it needs to know the two lines belong to one paragraph, which is a semantic judgement this package deliberately leaves to its consumers. Runs with empty text are dropped, and so are the empty words a whitespace-only run would otherwise produce, but no other normalisation of the decoded text is attempted: a ligature and a zero-width character each reach the output exactly as the font's ToUnicode mapping spelled them.
  * @param runs - positioned text runs, in any order
  * @param options - tolerance overrides; each defaults to the exported constant of the same name
  * @returns the grouped lines, in reading order

package/dist/text-group.js

@@ -4,8 +4,10 @@ const DEFAULT_WORD_GAP_EM = 1 / 8;
 const DEFAULT_COLUMN_GAP_EM = 1;
 const ROTATION_NOISE_DEG = 1e-6;
 const DEGREES_PER_TURN = 360;
-function normaliseRotationDeg(rotationDeg) {
-	return (Math.round((rotationDeg ?? 0) / ROTATION_NOISE_DEG) * ROTATION_NOISE_DEG % DEGREES_PER_TURN + DEGREES_PER_TURN) % DEGREES_PER_TURN;
+const VERTICAL_ADVANCE_OFFSET_DEG = -90;
+function advanceAngleDeg(run) {
+	const raw = (run.rotationDeg ?? 0) + (run.writingMode === "vertical" ? VERTICAL_ADVANCE_OFFSET_DEG : 0);
+	return (Math.round(raw / ROTATION_NOISE_DEG) * ROTATION_NOISE_DEG % DEGREES_PER_TURN + DEGREES_PER_TURN) % DEGREES_PER_TURN;
 }
 const RADIANS_PER_TURN = 2 * Math.PI;
 function baselineAxis(rotationDeg) {
@@ -41,8 +43,8 @@ function unproject(alongPt, acrossPt, rotationDeg) {
 * @returns true when the two baselines are within tolerance of each other
 */
 function runsShareBaseline(a, b, options = {}) {
-	const rotationDeg = normaliseRotationDeg(a.rotationDeg);
-	if (rotationDeg !== normaliseRotationDeg(b.rotationDeg)) return false;
+	const rotationDeg = advanceAngleDeg(a);
+	if (rotationDeg !== advanceAngleDeg(b) || a.writingMode !== b.writingMode) return false;
 	const toleranceEm = options.baselineToleranceEm ?? .6666666666666666;
 	return Math.abs(project(a, rotationDeg).acrossPt - project(b, rotationDeg).acrossPt) <= toleranceEm * Math.min(a.sizePt, b.sizePt);
 }
@@ -55,8 +57,8 @@ function runsShareBaseline(a, b, options = {}) {
 * @returns the gap in points, or undefined when it cannot be derived
 */
 function runGapPt(previous, next) {
-	const rotationDeg = normaliseRotationDeg(previous.rotationDeg);
-	if (rotationDeg !== normaliseRotationDeg(next.rotationDeg)) return;
+	const rotationDeg = advanceAngleDeg(previous);
+	if (rotationDeg !== advanceAngleDeg(next) || previous.writingMode !== next.writingMode) return;
 	const previousWidthPt = previous.widthPt;
 	if (previousWidthPt === void 0) return;
 	return project(next, rotationDeg).alongPt - (project(previous, rotationDeg).alongPt + previousWidthPt);
@@ -149,7 +151,7 @@ function buildWords(line, rotationDeg, wordGapEm, columnGapEm) {
 		...word.measurable ? { bounds: boundsOf(word.minAlongPt, word.maxAlongEndPt, line.anchor.acrossPt, word.maxSizePt, rotationDeg) } : {}
 	}));
 }
-function buildLine(line, rotationDeg, wordGapEm, columnGapEm) {
+function buildLine(line, rotationDeg, vertical, wordGapEm, columnGapEm) {
 	const words = buildWords(line, rotationDeg, wordGapEm, columnGapEm);
 	const text = words.map((word) => SEPARATOR_TEXT[word.separatorBefore] + word.text).join("");
 	let minAlongPt = Number.POSITIVE_INFINITY;
@@ -168,6 +170,7 @@ function buildLine(line, rotationDeg, wordGapEm, columnGapEm) {
 		words,
 		baselineYPt: line.anchor.acrossPt,
 		rotationDeg,
+		...vertical ? { writingMode: "vertical" } : {},
 		...measurable ? { bounds: boundsOf(minAlongPt, maxAlongEndPt, line.anchor.acrossPt, maxSizePt, rotationDeg) } : {}
 	};
 }
@@ -180,7 +183,7 @@ function buildLine(line, rotationDeg, wordGapEm, columnGapEm) {
 *
 * Grouping is by baseline alone, with no page segmentation: on a multi-column page whose columns are set at different vertical offsets, a line of one column can fall within tolerance of a line of the next and the two are reported as one line, because from geometry alone at this level that is what they are. The gutter between them still reads as a column boundary, so the separator says where to cut. A caller that needs the columns apart segments the page first, which is what document-outline.js's `segmentPdfRegions` is for, and groups each region's own runs.
 *
-* Known limitations, all of them inherent to what a PDF states rather than to this implementation. Text is reported in visual order, left to right along the baseline: a right-to-left script arrives from the content stream already laid out visually and carries no direction of its own, so a consumer needing logical order applies the Unicode Bidi Algorithm to the result. Vertical writing modes are not recognised, because this package's content interpreter does not read a CMap's WMode and so reports vertically set text with horizontal advances (ExaDev/documents.js#1358), which puts the positions beyond anything grouping could repair. A word hyphenated across a line end is left split, with its hyphen intact, because rejoining it needs to know the two lines belong to one paragraph, which is a semantic judgement this package deliberately leaves to its consumers. Runs with empty text are dropped, and so are the empty words a whitespace-only run would otherwise produce, but no other normalisation of the decoded text is attempted: a ligature and a zero-width character each reach the output exactly as the font's ToUnicode mapping spelled them.
+* Known limitations, all of them inherent to what a PDF states rather than to this implementation. Text is reported in visual order, left to right along the baseline: a right-to-left script arrives from the content stream already laid out visually and carries no direction of its own, so a consumer needing logical order applies the Unicode Bidi Algorithm to the result. A vertically set run is grouped into columns rather than lines, from the writingMode its own reader reported, and its column is reported with a rotationDeg of 270 and its own writingMode; columns order right to left, the direction vertical setting is read in. What is NOT recognised is a predefined non-Identity CMap's own byte decoding, so a vertically set font using one (90ms-RKSJ-V and its siblings) still has its codes read as two-byte CIDs, which is this package's own long-standing composite-font limit rather than anything about writing mode. A word hyphenated across a line end is left split, with its hyphen intact, because rejoining it needs to know the two lines belong to one paragraph, which is a semantic judgement this package deliberately leaves to its consumers. Runs with empty text are dropped, and so are the empty words a whitespace-only run would otherwise produce, but no other normalisation of the decoded text is attempted: a ligature and a zero-width character each reach the output exactly as the font's ToUnicode mapping spelled them.
 * @param runs - positioned text runs, in any order
 * @param options - tolerance overrides; each defaults to the exported constant of the same name
 * @returns the grouped lines, in reading order
@@ -189,20 +192,27 @@ function groupPdfTextRuns(runs, options = {}) {
 	const toleranceEm = options.baselineToleranceEm ?? .6666666666666666;
 	const wordGapEm = options.wordGapEm ?? .125;
 	const columnGapEm = options.columnGapEm ?? 1;
-	const byRotation = /* @__PURE__ */ new Map();
+	const buckets = /* @__PURE__ */ new Map();
 	for (const run of runs) {
 		if (run.text.length === 0) continue;
-		const rotationDeg = normaliseRotationDeg(run.rotationDeg);
-		const bucket = byRotation.get(rotationDeg);
-		if (bucket === void 0) byRotation.set(rotationDeg, [run]);
-		else bucket.push(run);
+		const rotationDeg = advanceAngleDeg(run);
+		const vertical = run.writingMode === "vertical";
+		const key = `${String(rotationDeg)}|${String(vertical)}`;
+		const bucket = buckets.get(key);
+		if (bucket === void 0) buckets.set(key, {
+			rotationDeg,
+			vertical,
+			runs: [run]
+		});
+		else bucket.runs.push(run);
 	}
 	const result = [];
-	for (const rotationDeg of [...byRotation.keys()].sort((a, b) => a - b)) {
-		const entries = (byRotation.get(rotationDeg) ?? []).map((run) => project(run, rotationDeg)).sort((a, b) => b.acrossPt - a.acrossPt || a.alongPt - b.alongPt);
+	const ordered = [...buckets.values()].sort((a, b) => a.rotationDeg - b.rotationDeg || Number(a.vertical) - Number(b.vertical));
+	for (const bucket of ordered) {
+		const entries = bucket.runs.map((run) => project(run, bucket.rotationDeg)).sort((a, b) => b.acrossPt - a.acrossPt || a.alongPt - b.alongPt);
 		for (const line of clusterIntoLines(entries, toleranceEm)) {
 			line.entries.sort((a, b) => a.alongPt - b.alongPt);
-			result.push(buildLine(line, rotationDeg, wordGapEm, columnGapEm));
+			result.push(buildLine(line, bucket.rotationDeg, bucket.vertical, wordGapEm, columnGapEm));
 		}
 	}
 	return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-parser.js",
-  "version": "5.1.0",
+  "version": "5.2.1",
   "description": "Hand-written, dependency-minimal PDF codec: parses arbitrary real-world PDFs and generates new ones, built on its own codec-owned LayoutDocument item model and Zod 4 codecs.",
   "type": "module",
   "repository": {
@@ -73,7 +73,7 @@
   "license": "MIT",
   "dependencies": {
     "byte-codec": "1.6.3",
-    "document-schema.js": "7.11.5",
+    "document-schema.js": "7.12.0",
     "fflate": "0.8.3",
     "zod": "4.4.3"
   },