reamkit 1.33.0 → 1.33.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Alex Krassavin
+Copyright (c) 2026 Alexandr Krassavin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -59,8 +59,9 @@ and `doc.convertWithReport(...)` returns `{ bytes, losses }` (pass
 are plain `Uint8Array`s, so wiring this to files, the network, or disk is up
 to you.
 
-An encrypted source opens with its password — a PDF's user password, or an
-Office package's (MS-OFFCRYPTO, Agile and Standard):
+An encrypted source opens with its password — a PDF's user or owner password,
+or an Office package's (MS-OFFCRYPTO, Agile and Standard). A wrong one, or none
+where one is needed, throws `WrongPasswordError`:
 
 ```ts
 const doc = Ream.parse(bytes, { password: 'secret' });
@@ -253,14 +254,17 @@ itself whether a file is a document to re-flow or a page to keep — a paper is
 mostly lines, a form is mostly marks — and there is nothing to configure: a
 caller cannot know which of the two it was handed. It reads modern compressed
 files (cross-reference + object streams) and encrypted ones (RC4 / AES — the
-user password is passed to `Ream.parse(bytes, { password })`, defaulting to the
-permissions-only case); a filter it does not carry can be handed to it through
-`Ream.parse(bytes, { filters })`.
+user or owner password is passed to `Ream.parse(bytes, { password })`,
+defaulting to the permissions-only case, and one that opens the file as neither
+throws `WrongPasswordError`); a filter it does not carry can be handed to it
+through `Ream.parse(bytes, { filters })`.
 
 A form or a drawing is not a reflowable document, so the reader keeps it as a
 page instead: every line stands where its glyphs stand, beside the artwork, the
 way up the page is shown. Which of the two readings a file gets it decides
-itself and records in the losses.
+itself and records in the losses. Markdown, which places nothing, reads a page
+kept only for its table's rules, or for letters the file names no character
+for, as the document it is without them.
 
 **Reads PowerPoint, too.** `Ream.parse` accepts a `.pptx` and turns each slide
 into a page at the deck size — text boxes (with run formatting, alignment,
@@ -291,4 +295,4 @@ and known limitations.
 
 ## License
 
-[MIT](./LICENSE) © Alex Krassavin
+[MIT](./LICENSE) — Copyright (c) 2026 Alexandr Krassavin

package/dist/esm/core/converter/facade.js

@@ -35,8 +35,9 @@ import { pdfReader } from "../../pdf-reader/reader.js";
 function toFlowDoc(doc, options = {}) {
 	return doc.kind === "sheet" ? projectSheetDoc(doc, options) : doc;
 }
-function readToFlow(reader, bytes, options = {}) {
-	const { doc, losses } = reader.read(bytes);
+function readToFlow(reader, bytes, options = {}, placesNothing = false) {
+	const read = reader.read(bytes);
+	const { doc, losses } = (placesNothing ? read.flowing?.() : void 0) ?? read;
 	return {
 		doc: toFlowDoc(doc, options),
 		losses
@@ -93,7 +94,10 @@ function createConverter(opts = {}) {
 			};
 		}
 		if (to === "md") {
-			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes, rest.now ? { now: rest.now } : void 0);
+			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes, {
+				...rest.now ? { now: rest.now } : {},
+				spill: false
+			}, true);
 			losses.push(...readLosses);
 			const markdown = writeMarkdown(flow);
 			losses.push(...markdown.losses);

package/dist/esm/core/converter/ream.d.ts

@@ -130,6 +130,7 @@ export declare class Ream {
     readonly losses: ReadonlyArray<Loss>;
     private readonly source;
     private readonly readerId;
+    private readonly flowing?;
     /**
      * @param flow     The interlayer — the parsed, format-neutral document tree.
      * @param sheet    The native SpreadsheetML tree when the source is a spreadsheet
@@ -138,8 +139,13 @@ export declare class Ream {
      * @param source   The original source bytes (kept only for docx auto-fonts and
      *                 PDF/A-3 `embedSource`).
      * @param readerId The id of the reader that parsed the source.
+     * @param flowing  The source read as a document that flows, where the reader
+     *                 kept it as a page for marks Markdown drops anyway (see
+     *                 {@link ReadResult.flowing}).
      */
     private constructor();
+    /** The flowing reading, once Markdown has asked for it. */
+    private flowingRead;
     /**
      * Sniff the format and parse the bytes once into the {@link FlowDoc} interlayer.
      *
@@ -148,6 +154,9 @@ export declare class Ream {
      *                encrypted source.
      * @returns A reusable {@link Ream} instance.
      * @throws Error when no registered reader recognizes the bytes.
+     * @throws WrongPasswordError when the bytes are encrypted — an Office package
+     *         or a PDF — and the password does not open them, or none was given
+     *         where one is needed.
      */
     static parse(bytes: Uint8Array, options?: ReamParseOptions): Ream;
     /** The source format id (`'docx'`, `'xlsx'`, …). */

package/dist/esm/core/converter/ream.js

@@ -15,6 +15,7 @@ import { writeXlsx } from "../../excel/xlsx-writer.js";
 import { writeHtml } from "../../html/html-writer.js";
 import { writeMarkdown } from "../../markdown/markdown-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
+import { WrongPasswordError } from "../crypto/password-error.js";
 import { DEFAULT_READERS, resolveFontsViaChain, toFlowDoc } from "./facade.js";
 import { familiesInFlow } from "../fonts/families.js";
 import { decryptPackage, isEncryptedPackage } from "../crypto/offcrypto.js";
@@ -58,6 +59,7 @@ var Ream = class Ream {
 	losses;
 	source;
 	readerId;
+	flowing;
 	/**
 	* @param flow     The interlayer — the parsed, format-neutral document tree.
 	* @param sheet    The native SpreadsheetML tree when the source is a spreadsheet
@@ -66,14 +68,20 @@ var Ream = class Ream {
 	* @param source   The original source bytes (kept only for docx auto-fonts and
 	*                 PDF/A-3 `embedSource`).
 	* @param readerId The id of the reader that parsed the source.
+	* @param flowing  The source read as a document that flows, where the reader
+	*                 kept it as a page for marks Markdown drops anyway (see
+	*                 {@link ReadResult.flowing}).
 	*/
-	constructor(flow, sheet, losses, source, readerId) {
+	constructor(flow, sheet, losses, source, readerId, flowing) {
 		this.flow = flow;
 		this.sheet = sheet;
 		this.losses = losses;
 		this.source = source;
 		this.readerId = readerId;
+		this.flowing = flowing;
 	}
+	/** The flowing reading, once Markdown has asked for it. */
+	flowingRead;
 	/**
 	* Sniff the format and parse the bytes once into the {@link FlowDoc} interlayer.
 	*
@@ -82,22 +90,32 @@ var Ream = class Ream {
 	*                encrypted source.
 	* @returns A reusable {@link Ream} instance.
 	* @throws Error when no registered reader recognizes the bytes.
+	* @throws WrongPasswordError when the bytes are encrypted — an Office package
+	*         or a PDF — and the password does not open them, or none was given
+	*         where one is needed.
 	*/
 	static parse(bytes, options = {}) {
 		const readers = options.readers ?? DEFAULT_READERS;
 		let source = bytes;
 		if (isEncryptedPackage(bytes)) {
-			if (options.password === void 0) throw new Error("Password-protected OOXML document (ECMA-376 §2.3 EncryptedPackage) — pass the password as `password`");
+			if (options.password === void 0) throw new WrongPasswordError("Password-protected OOXML document (ECMA-376 §2.3 EncryptedPackage) — pass the password as `password`");
 			source = decryptPackage(bytes, options.password);
 		}
 		const reader = readers.find((r) => r.sniff(source));
 		if (!reader) throw new Error(`Unrecognized document format (readers: ${readers.map((r) => r.id).join(", ")})`);
-		const { doc, losses } = reader.read(source, {
+		const { doc, losses, flowing } = reader.read(source, {
 			password: options.password,
 			...options.filters ? { filters: options.filters } : {}
 		});
 		const sheet = doc.kind === "sheet" ? doc : void 0;
-		return new Ream(toFlowDoc(doc), sheet, losses, bytes, reader.id);
+		const reflow = flowing ? () => {
+			const read = flowing();
+			return {
+				doc: toFlowDoc(read.doc),
+				losses: read.losses
+			};
+		} : void 0;
+		return new Ream(toFlowDoc(doc), sheet, losses, bytes, reader.id, reflow);
 	}
 	/** The source format id (`'docx'`, `'xlsx'`, …). */
 	get format() {
@@ -147,11 +165,16 @@ var Ream = class Ream {
 			};
 		}
 		if (to === "md") {
+			if (this.flowing) {
+				this.flowingRead ??= this.flowing();
+				losses.splice(0, this.losses.length, ...this.flowingRead.losses);
+			}
 			const source = this.sheet && options.sheetNames !== false ? projectSheetDoc(this.sheet, {
 				...options.now ? { now: options.now } : {},
 				...options.fileName ? { fileName: options.fileName } : {},
-				sheetHeadings: true
-			}) : flow;
+				sheetHeadings: true,
+				spill: false
+			}) : this.flowingRead?.doc ?? flow;
 			const markdown = writeMarkdown(source, {
 				...options.images ? { images: options.images } : {},
 				...options.pageBreaks ? { pageBreaks: options.pageBreaks } : {}

package/dist/esm/core/crypto/offcrypto.d.ts

@@ -1,8 +1,5 @@
-/** Thrown when the bytes are encrypted and the password does not open them. */
-export declare class WrongPasswordError extends Error {
-    /** @param message The message to carry; the default states the failure. */
-    constructor(message?: string);
-}
+import { WrongPasswordError } from './password-error.js';
+export { WrongPasswordError };
 /** Whether the bytes are an OOXML package encrypted per ECMA-376 §2.3. */
 export declare function isEncryptedPackage(bytes: Uint8Array): boolean;
 /**

package/dist/esm/core/crypto/offcrypto.js

@@ -1,14 +1,7 @@
 import { aesCbcDecrypt, aesEcbDecrypt, sha1, sha256, sha384, sha512 } from "./primitives.js";
 import { openCfb } from "../ole/cfb.js";
+import { WrongPasswordError } from "./password-error.js";
 //#region src/core/crypto/offcrypto.ts
-/** Thrown when the bytes are encrypted and the password does not open them. */
-var WrongPasswordError = class extends Error {
-	/** @param message The message to carry; the default states the failure. */
-	constructor(message = "Wrong password for this document") {
-		super(message);
-		this.name = "WrongPasswordError";
-	}
-};
 /** Whether the bytes are an OOXML package encrypted per ECMA-376 §2.3. */
 function isEncryptedPackage(bytes) {
 	try {

package/dist/esm/core/crypto/password-error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Thrown when the bytes are encrypted and the password does not open them —
+ * the wrong one, or none where one is needed.
+ */
+export declare class WrongPasswordError extends Error {
+    /** @param message The message to carry; the default states the failure. */
+    constructor(message?: string);
+}

package/dist/esm/core/crypto/password-error.js

@@ -0,0 +1,14 @@
+//#region src/core/crypto/password-error.ts
+/**
+* Thrown when the bytes are encrypted and the password does not open them —
+* the wrong one, or none where one is needed.
+*/
+var WrongPasswordError = class extends Error {
+	/** @param message The message to carry; the default states the failure. */
+	constructor(message = "Wrong password for this document") {
+		super(message);
+		this.name = "WrongPasswordError";
+	}
+};
+//#endregion
+export { WrongPasswordError };

package/dist/esm/core/ir/adapters.d.ts

@@ -12,6 +12,15 @@ export interface ReadResult<TDoc> {
     readonly doc: TDoc;
     /** Losses recorded while reading. */
     readonly losses: LossReport;
+    /**
+     * The same source read again as a document that flows, for a medium that
+     * places nothing — Markdown. Present only where the reader kept the source as
+     * a page for marks such a medium drops anyway: a PDF whose words are mostly
+     * glyphs it names no character for, or whose tables are ruled, kept where its
+     * marks stand so that a paged medium can show them exactly. Called only by
+     * that medium, so the source is read twice only when it asks.
+     */
+    readonly flowing?: () => ReadResult<TDoc>;
 }
 /**
  * A synchronous reader for one source format (ir-design §7). All async I/O —

package/dist/esm/excel/print-model.d.ts

@@ -123,6 +123,7 @@ export declare function printableHeightPt(worksheet: ParsedWorksheet): number;
 interface PrintModelOptions {
     readonly screen?: boolean;
     readonly image?: boolean;
+    readonly spill?: boolean;
     readonly printArea?: CellRange;
     readonly gridLines: boolean;
     readonly titleRows?: {

package/dist/esm/excel/print-model.js

@@ -903,24 +903,18 @@ function gridBody(worksheet, sharedStrings, styles, date1904, print) {
 			const rotation = xf?.alignment?.textRotation;
 			const rotated = rotation !== void 0 && rotation !== 0 && text.length > 0;
 			const shrinkToFit = xf?.alignment?.shrinkToFit === true && !wrapText && !rotated;
-			if (text.length > 0 && !merge && !wrapText && !rotated && !shrinkToFit && ws && (ws.type === "s" || ws.type === "str" || ws.type === "inlineStr") && (flow === "left" || flow === "center") && estimateChars(text) * charTwips(xf, styles, textTwipsUnit) > columnWidths[c]) {
-				let availTwips = columnWidths[c];
+			if (print.spill !== false && text.length > 0 && !merge && !wrapText && !rotated && !shrinkToFit && ws && (ws.type === "s" || ws.type === "str" || ws.type === "inlineStr") && (flow === "left" || flow === "center") && estimateChars(text) * charTwips(xf, styles, textTwipsUnit) > columnWidths[c]) {
 				let cc = c + 1;
 				const neighbourIsFree = (col) => !cellHasContent(cellMatrix[r]?.[col]) && !insideMerge.has(key(absR, col + colStart)) && !mergeOrigins.has(key(absR, col + colStart)) && (!cellPaintsSomething(cellMatrix[r]?.[col], styles) || spanPreservesPaint(cellMatrix[r]?.[col], styles, shading, borders)) && !sparklineByCell.has(key(absR, col + colStart)) && !(dropdownRanges.length > 0 && rangesCover(dropdownRanges, absR, col + colStart));
 				const bandEnd = bandEndOfCol.get(c) ?? colCount - 1;
-				while (cc <= bandEnd && (hiddenCols.has(cc) || neighbourIsFree(cc))) {
-					if (!hiddenCols.has(cc)) availTwips += columnWidths[cc];
-					cc++;
-				}
+				while (cc <= bandEnd && (hiddenCols.has(cc) || neighbourIsFree(cc))) cc++;
 				if (cc <= bandEnd && !cellHasContent(cellMatrix[r]?.[cc]) && !sparklineByCell.has(key(absR, cc + colStart)) && !(dropdownRanges.length > 0 && rangesCover(dropdownRanges, absR, cc + colStart))) {
 					const rule = absorbableRightRule(cellMatrix[r]?.[cc], styles, shading, borders);
 					if (rule) {
-						availTwips += columnWidths[cc];
 						overflowRightRule = rule;
 						cc++;
 					}
 				}
-				text = clipToWidth(text, availTwips * 1.1, charTwips(xf, styles, textTwipsUnit));
 				if (cc > c + 1) {
 					overflowSpan = 0;
 					for (let k = c; k < cc; k++) if (!hiddenCols.has(k)) overflowSpan++;
@@ -932,11 +926,6 @@ function gridBody(worksheet, sharedStrings, styles, date1904, print) {
 						paintColumns++;
 					}
 				}
-			} else if (text.length > 0 && merge && !wrapText && !rotated && !shrinkToFit) {
-				const lastCol = Math.min(merge.endColumn - colStart, bandEndOfCol.get(c) ?? colCount - 1);
-				let availTwips = 0;
-				for (let k = c; k <= lastCol; k++) if (!hiddenCols.has(k)) availTwips += columnWidths[k] ?? 0;
-				text = clipToWidth(text, availTwips * 1.1, charTwips(xf, styles, textTwipsUnit));
 			}
 			if (shrinkToFit && ws && text.length > 0) {
 				const drawnTwips = estimateChars(text) / charWidthUnits("0") * charTwips(xf, styles, textTwipsUnit);
@@ -1004,7 +993,7 @@ function gridBody(worksheet, sharedStrings, styles, date1904, print) {
 					runs
 				}
 			}));
-			if (text.length > 0 && !merge && !wrapText && !rotated && !shrinkToFit && c > 0 && flow === "right" && estimateChars(text) * charTwips(xf, styles, textTwipsUnit) > columnWidths[c]) leftOverflow.push({
+			if (print.spill !== false && text.length > 0 && !merge && !wrapText && !rotated && !shrinkToFit && c > 0 && flow === "right" && estimateChars(text) * charTwips(xf, styles, textTwipsUnit) > columnWidths[c]) leftOverflow.push({
 				index: cells.length,
 				column: c,
 				needTwips: estimateChars(text) * charTwips(xf, styles, textTwipsUnit) - columnWidths[c],
@@ -1998,20 +1987,6 @@ function estimateChars(text) {
 	for (const ch of text) n += charWidthUnits(ch);
 	return n;
 }
-/** The longest prefix of `text` that fits `availTwips`, by the same estimate. */
-function clipToWidth(text, availTwips, perChar) {
-	if (perChar <= 0) return text;
-	const budget = availTwips / perChar;
-	let used = 0;
-	let i = 0;
-	for (const ch of text) {
-		const w = charWidthUnits(ch);
-		if (used + w > budget) break;
-		used += w;
-		i += ch.length;
-	}
-	return i >= text.length ? text : text.slice(0, Math.max(1, i));
-}
 /**
 * Widen each right-aligned cell that overflows leftwards over the free columns
 * before it, deleting the cells those columns produced.

package/dist/esm/excel/sheet-to-flow.d.ts

@@ -69,6 +69,14 @@ export interface ProjectSheetOptions {
      * on it (`fitPagesToContent`). The SVG target asks for this.
      */
     readonly wholeSheetPages?: boolean;
+    /**
+     * Let a cell's text run on over its empty neighbours, as a printed or shown
+     * sheet does — modelled as a span from the cell over them. On by default.
+     * Off for a medium that keeps cells and not widths: markdown has no column
+     * for text to run on into, and a spill to the LEFT moved a right-aligned
+     * label into the column before its own.
+     */
+    readonly spill?: boolean;
 }
 /**
  * Project a {@link SheetDoc} into a {@link FlowDoc} (E-SHEET SA2): each grid sheet

package/dist/esm/excel/sheet-to-flow.js

@@ -82,6 +82,7 @@ function projectSheetDoc(sheet, options = {}) {
 		const titleRows = screen ? void 0 : resolvePrintTitleRows(sheet.definedNames, sheetIdx);
 		const gridBody = worksheetToBody(ws.grid, sheet.sharedStrings, sheet.styles, sheet.date1904, {
 			...screen ? { screen } : {},
+			...options.spill === false ? { spill: false } : {},
 			...screen && options.wholeSheetPages === true ? { image: true } : {},
 			...printArea ? { printArea } : {},
 			...titleRows ? { titleRows } : {},

package/dist/esm/index.js

@@ -19,7 +19,8 @@ import { docxWriter, writeDocx } from "./word/docx-writer.js";
 import { htmlWriter, writeHtml } from "./html/html-writer.js";
 import { markdownWriter, writeMarkdown } from "./markdown/markdown-writer.js";
 import { svgWriter, writeSvg } from "./svg/svg-writer.js";
+import { WrongPasswordError } from "./core/crypto/password-error.js";
 import { createConverter } from "./core/converter/facade.js";
-import { WrongPasswordError, isEncryptedPackage } from "./core/crypto/offcrypto.js";
+import { isEncryptedPackage } from "./core/crypto/offcrypto.js";
 import { Ream } from "./core/converter/ream.js";
 export { ConversionLossError, FEATURES, FontRegistry, NO_FONT, Ream, ResourceStore, WrongPasswordError, callerFontProvider, chainProviders, createConverter, createHyphenator, createLanguageHyphenator, docxReader, docxWriter, eighthPtToPt, embeddedDocFontProvider, emuToPt, fetchFontSet, formatLoss, getHyphenator, halfPtToPt, htmlWriter, inchToPt, isEmbeddingRestricted, isEncryptedPackage, layoutStyledDocument, localFontProvider, markdownWriter, mmToPt, parseTtf, pt, pxToPt, readDocx, readOs2FsType, readXlsx, remoteFontProvider, renderStyledPdf, resolveFamilyKey, signPdf, splitPatternBundle, subsetTtf, svgWriter, twipsToPt, writeDocx, writeHtml, writeMarkdown, writeSvg, xlsxReader };

package/dist/esm/layout/styled-layout.js

@@ -4983,7 +4983,7 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 			const block = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, noWrap ? NO_WRAP_MEASURE_WIDTH : measureWidth);
 			const cutAt = widthPt - padLeftPt;
 			if (noWrap && (block.lines[0]?.contentWidthPt ?? 0) > cutAt) clipped = true;
-			const keep = noWrap ? clipLineToWidth(block.lines, cutAt, cell.properties.hashOnOverflow === true) : block.lines;
+			const keep = noWrap ? oneLineInBox(block.lines, cutAt, cell.properties.hashOnOverflow === true) : block.lines;
 			const markOnly = cell.properties.hideMark === true && el.paragraph.runs.every((r) => r.text === "");
 			if (!markOnly) openParagraph(block.spacingBeforePt);
 			for (const line of keep) {
@@ -6781,7 +6781,7 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 			textY -= cell.lineGaps?.get(lineIdx) ?? 0;
 			const h = computeLineHeight(line, line.resolved);
 			textY -= h;
-			const offset = alignmentOffset(line.resolved.alignment, line.contentWidthPt, cell.widthPt - cell.padLeftPt - cell.padRightPt);
+			const offset = (cell.clipped === true ? overrunOffset : alignmentOffset)(line.resolved.alignment, line.contentWidthPt, cell.widthPt - cell.padLeftPt - cell.padRightPt);
 			const indentLeft = line.resolved.indentLeft + (line.firstLine ? line.resolved.indentFirstLine : 0);
 			out.push({
 				type: "line",
@@ -6920,51 +6920,37 @@ function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx,
 }
 var NO_WRAP_MEASURE_WIDTH = 1e6;
 /**
-* One line, trimmed to the glyph that STRADDLES `widthPt` — what a non-wrapping
-* spreadsheet cell shows. Excel and LibreOffice paint that glyph and cut it
-* through the middle, and so do we now: the caller marks the cell and the
-* emitters clip the line to its box (TextLineItem.clip). Stopping at the last
-* glyph that wholly fits is what dropped a character off every cut cell.
+* The one line a non-wrapping spreadsheet cell shows — WHOLE. Excel and
+* LibreOffice set such a cell's text on one line and let its box cut it, through
+* the glyph the edge falls on: on the right of left-aligned text, on both sides
+* of centred text, on the left of right-aligned text. So the caller marks the
+* cell, sets the line by its alignment (see {@link overrunOffset}) and the
+* emitters clip it to the box (TextLineItem.clip).
+*
+* It was trimmed to the glyph that straddles the edge instead, which cut every
+* centred and right-aligned cell on the wrong side and left the page's text
+* holding only what showed — "Монтаж кровл" of "Монтаж кровли".
+*
+* @param lines          The cell paragraph's lines, laid out unbroken.
+* @param widthPt        How far the cell's box reaches.
+* @param hashOnOverflow Whether a number too wide for the box shows as `#`.
+* @returns The first line, or the `#` that stand for it.
 */
-function clipLineToWidth(lines, widthPt, hashOnOverflow = false) {
+function oneLineInBox(lines, widthPt, hashOnOverflow = false) {
 	const line = lines[0];
 	if (!line) return [];
-	if (line.contentWidthPt <= widthPt) return [line];
-	if (hashOnOverflow) return [hashFill(line, widthPt)];
-	const tokens = [];
-	let used = 0;
-	for (const token of line.tokens) {
-		const advance = token.widthPt;
-		if (used + advance <= widthPt) {
-			tokens.push(token);
-			used += advance;
-			continue;
-		}
-		if (token.kind === "text") {
-			const room = widthPt - used;
-			let text = "";
-			let textWidth = 0;
-			for (const ch of token.text) {
-				if (textWidth >= room) break;
-				text += ch;
-				textWidth = token.font.measure.textWidthPt(text, token.fontSizePt);
-			}
-			if (text.length > 0) {
-				tokens.push({
-					...token,
-					text,
-					widthPt: textWidth
-				});
-				used += textWidth;
-			}
-		}
-		break;
-	}
-	return [{
-		...line,
-		tokens,
-		contentWidthPt: used
-	}];
+	if (hashOnOverflow && line.contentWidthPt > widthPt) return [hashFill(line, widthPt)];
+	return [line];
+}
+/**
+* {@link alignmentOffset} for a line that may be wider than its room: the
+* offset may go below zero, putting the start of a centred or right-aligned
+* line before the box for the box's clip to cut.
+*/
+function overrunOffset(alignment, lineWidth, available) {
+	if (alignment === "right") return available - lineWidth;
+	if (alignment === "center") return (available - lineWidth) / 2;
+	return 0;
 }
 /**
 * The line as a row of `#` filling `widthPt` — what Excel and LibreOffice put in

package/dist/esm/markdown/markdown-writer.js

@@ -145,13 +145,14 @@ function emitShape(out, shape, ctx) {
 function emitParagraph(out, p, ctx) {
 	const resolved = resolveParagraphProperties(p.properties, EMPTY_STYLE_SHEET);
 	const anchors = bookmarkAnchors(p, ctx);
-	const text = inlineRuns(p.runs, p, ctx).replace(/^[ \t]+/, "");
+	const level = headingLevelOf(resolved);
+	const asHeading = level !== void 0 && !ctx.inCell;
+	const text = inlineRuns(p.runs, p, ctx, asHeading).replace(/^[ \t]+/, "");
 	const inline = anchors + text;
 	const marker = markerText(p, ctx);
 	reportParagraphLosses(resolved, ctx);
 	if (breaksPage(p, resolved)) emitRule(out, ctx);
 	const empty = isBlank(text) && anchors.length === 0;
-	const level = headingLevelOf(resolved);
 	if (level !== void 0) {
 		if (empty) return;
 		ctx.list.length = 0;
@@ -602,8 +603,11 @@ function cellInline(cell, ctx) {
 * characters on either side of it (§6.2), and those belong to the NEIGHBOURING
 * spans: the first pass coalesces runs into spans, the second dresses each
 * span knowing what stands beside it.
+*
+* @param heading Whether the paragraph is a heading, which every renderer of
+*                one sets strong already.
 */
-function inlineRuns(runs, p, ctx) {
+function inlineRuns(runs, p, ctx, heading = false) {
 	const pieces = [];
 	let pending;
 	const flush = () => {
@@ -621,8 +625,11 @@ function inlineRuns(runs, p, ctx) {
 		const resolved = resolveRunProperties(run.properties, p.properties, EMPTY_STYLE_SHEET);
 		reportRunLosses(resolved, ctx);
 		const marks = marksOf(resolved, run);
-		if (pending && sameMarks(pending.marks, marks)) pending.text += run.text;
-		else {
+		const joined = pending && joinedMarks(pending, marks, run.text);
+		if (pending && joined) {
+			pending.marks = joined;
+			pending.text += run.text;
+		} else {
 			flush();
 			pending = {
 				marks,
@@ -631,18 +638,52 @@ function inlineRuns(runs, p, ctx) {
 		}
 	}
 	flush();
+	const spans = pieces.filter((piece) => "marks" in piece && !isWhitespace(piece.text));
+	const plain = heading && spans.length > 0 && spans.every((piece) => piece.marks.bold) ? pieces.map((piece) => "marks" in piece ? {
+		...piece,
+		marks: {
+			...piece.marks,
+			bold: false
+		}
+	} : piece) : pieces;
 	let out = "";
-	for (let i = 0; i < pieces.length; i++) {
-		const piece = pieces[i];
+	for (let i = 0; i < plain.length; i++) {
+		const piece = plain[i];
 		if ("literal" in piece) {
 			out += piece.literal;
 			continue;
 		}
-		out += applyMarks(piece.text, piece.marks, ctx, out.slice(-1), leadOf(pieces, i + 1));
+		out += applyMarks(piece.text, piece.marks, ctx, out.slice(-1), leadOf(plain, i + 1));
 	}
 	return out;
 }
 /**
+* The marks a span keeps when the next run joins it, or nothing where the two
+* must stay apart.
+*
+* The same marks join, as they always did. And a run of WHITESPACE joins its
+* neighbour whatever its emphasis, for emphasis does not show on a space: a
+* PDF from TeX sets no space between two words at all, the reader writes one
+* in the plain face, and a bold title came back `**Trace-based**
+* **Just-in-Time** **Type**`, broken at every word. A line under or through a
+* space does show, and so does a link over it — those must still agree.
+*
+* @param span The span so far.
+* @param next The next run's marks.
+* @param text The next run's text.
+* @returns The marks the joined span carries, or `undefined`.
+*/
+function joinedMarks(span, next, text) {
+	if (sameMarks(span.marks, next)) return span.marks;
+	if (span.marks.strike !== next.strike || span.marks.underline !== next.underline || span.marks.href !== next.href || span.marks.anchor !== next.anchor) return void 0;
+	if (isWhitespace(text)) return span.marks;
+	if (isWhitespace(span.text)) return next;
+}
+/** Whether the text is whitespace and nothing else — a space, a tab, a break. */
+function isWhitespace(text) {
+	return /^\s+$/u.test(text);
+}
+/**
 * The first character the next span will contribute. A dressed span always
 * begins with its delimiter or its html tag — both punctuation — so a marked
 * neighbour answers without being rendered first.

package/dist/esm/pdf-reader/decrypt.d.ts

@@ -7,16 +7,28 @@ export interface Decryptor {
      */
     decrypt: (value: PdfValue, objNum: number, gen: number) => PdfValue;
 }
+/**
+ * What {@link buildDecryptor} makes of a file: the decryptor, or why there is
+ * none — the password opens it as neither its user nor its owner, or the file is
+ * locked by a handler this does not implement.
+ */
+export type DecryptorResult = {
+    readonly decryptor: Decryptor;
+} | {
+    readonly refused: 'password' | 'handler';
+};
 /**
  * Build a {@link Decryptor} from the `/Encrypt` dictionary and the file `/ID`
- * (ISO 32000 §7.6.3 / ISO 32000-2 §7.6.4). Derives the file key for the
- * handler's revision — R6/V5 via `/UE` (AES-256), else the legacy MD5 key — and
+ * (ISO 32000 §7.6.3 / ISO 32000-2 §7.6.4). Authenticates the password as the
+ * user's and then as the owner's, derives the file key for the handler's
+ * revision — R6/V5 via `/UE` or `/OE` (AES-256), else the legacy MD5 key — and
  * picks the cipher (RC4, AES-128 `/AESV2`, AES-256 `/AESV3`).
  *
  * @param encrypt  The `/Encrypt` dictionary.
  * @param idArray  The trailer `/ID` array (its first element seeds the legacy key).
- * @param password The user password (EP14); the empty string opens permissions-only encryption.
- * @returns A decryptor, or `undefined` for a non-Standard filter, an unencrypting
- *          crypt filter, or a password that fails key validation.
+ * @param password The password (EP14), the user's or the owner's; the empty
+ *                 string opens permissions-only encryption.
+ * @returns The decryptor, or why there is none: a password the file's own
+ *          verifiers refuse, or a non-Standard filter or unencrypting crypt filter.
  */
-export declare function buildDecryptor(encrypt: PdfDict, idArray: PdfValue | undefined, password?: string): Decryptor | undefined;
+export declare function buildDecryptor(encrypt: PdfDict, idArray: PdfValue | undefined, password?: string): DecryptorResult;

package/dist/esm/pdf-reader/decrypt.js

@@ -45,50 +45,73 @@ var ZERO16 = /* @__PURE__ */ new Uint8Array(16);
 var EMPTY = /* @__PURE__ */ new Uint8Array(0);
 /**
 * Build a {@link Decryptor} from the `/Encrypt` dictionary and the file `/ID`
-* (ISO 32000 §7.6.3 / ISO 32000-2 §7.6.4). Derives the file key for the
-* handler's revision — R6/V5 via `/UE` (AES-256), else the legacy MD5 key — and
+* (ISO 32000 §7.6.3 / ISO 32000-2 §7.6.4). Authenticates the password as the
+* user's and then as the owner's, derives the file key for the handler's
+* revision — R6/V5 via `/UE` or `/OE` (AES-256), else the legacy MD5 key — and
 * picks the cipher (RC4, AES-128 `/AESV2`, AES-256 `/AESV3`).
 *
 * @param encrypt  The `/Encrypt` dictionary.
 * @param idArray  The trailer `/ID` array (its first element seeds the legacy key).
-* @param password The user password (EP14); the empty string opens permissions-only encryption.
-* @returns A decryptor, or `undefined` for a non-Standard filter, an unencrypting
-*          crypt filter, or a password that fails key validation.
+* @param password The password (EP14), the user's or the owner's; the empty
+*                 string opens permissions-only encryption.
+* @returns The decryptor, or why there is none: a password the file's own
+*          verifiers refuse, or a non-Standard filter or unencrypting crypt filter.
 */
 function buildDecryptor(encrypt, idArray, password = "") {
 	const filter = encrypt.get("Filter");
-	if (!(filter instanceof PdfName) || filter.value !== "Standard") return void 0;
+	if (!(filter instanceof PdfName) || filter.value !== "Standard") return { refused: "handler" };
 	const v = numOf(encrypt.get("V"));
 	const r = numOf(encrypt.get("R"));
+	const o = strBytes(encrypt.get("O"));
+	const u = strBytes(encrypt.get("U"));
+	const methods = cryptMethods(encrypt, v, r);
+	if (methods.stream === "none" && methods.string === "none") return { decryptor: { decrypt: (value) => value } };
 	let fileKey;
-	let method;
-	if (r >= 5 || v >= 5) {
-		fileKey = deriveKeyR6(strBytes(encrypt.get("U")), strBytes(encrypt.get("UE")), password);
-		method = "aesv3";
-	} else {
-		const keyLen = (numOf(encrypt.get("Length")) || 40) / 8;
+	if (r >= 5 || v >= 5) fileKey = userKeyR6(u, strBytes(encrypt.get("UE")), password) ?? ownerKeyR6(o, u, strBytes(encrypt.get("OE")), password);
+	else {
+		const keyLen = Math.max(5, Math.min(16, (numOf(encrypt.get("Length")) || 40) / 8));
 		const id0 = Array.isArray(idArray) ? strBytes(idArray[0]) : EMPTY;
-		fileKey = deriveKeyLegacy(strBytes(encrypt.get("O")), numOf(encrypt.get("P")) | 0, id0, r, Math.max(5, Math.min(16, keyLen)), encrypt.get("EncryptMetadata") !== false, password);
-		const m = cipherMethod(encrypt, v);
-		if (m === void 0) return void 0;
-		method = m;
+		const keyFor = (padded) => {
+			const key = deriveKeyLegacy(o, numOf(encrypt.get("P")) | 0, id0, r, keyLen, encrypt.get("EncryptMetadata") !== false, padded);
+			return userKeyMatches(key, r, id0, u) ? key : void 0;
+		};
+		fileKey = keyFor(padPassword(password)) ?? keyFor(userPasswordFromOwner(password, o, r, keyLen));
 	}
-	if (!fileKey) return void 0;
+	if (!fileKey) return { refused: "password" };
 	const key = fileKey;
-	return { decrypt: (value, objNum, gen) => decryptValue(value, objNum, gen, key, method) };
+	return { decryptor: { decrypt: (value, objNum, gen) => decryptValue(value, objNum, gen, key, methods) } };
 }
-function deriveKeyLegacy(o, p, id0, r, keyLen, encryptMetadata, password) {
+function deriveKeyLegacy(o, p, id0, r, keyLen, encryptMetadata, padded) {
 	const tail = r >= 4 && !encryptMetadata ? Uint8Array.from([
 		255,
 		255,
 		255,
 		255
 	]) : EMPTY;
-	let hash = md5(concat(padPassword(password), o.subarray(0, 32), p32le(p), id0, tail));
+	let hash = md5(concat(padded, o.subarray(0, 32), p32le(p), id0, tail));
 	if (r >= 3) for (let i = 0; i < 50; i++) hash = md5(hash.subarray(0, keyLen));
 	return hash.subarray(0, keyLen);
 }
-function deriveKeyR6(u, ue, password) {
+function userKeyMatches(key, r, id0, u) {
+	if (r <= 2) return u.length < 32 || equal(rc4(key, PAD), u.subarray(0, 32));
+	if (u.length < 16) return true;
+	let x = rc4(key, md5(concat(PAD, id0)));
+	for (let i = 1; i <= 19; i++) x = rc4(xorKey(key, i), x);
+	return equal(x, u.subarray(0, 16));
+}
+function userPasswordFromOwner(owner, o, r, keyLen) {
+	let hash = md5(padPassword(owner));
+	if (r >= 3) for (let i = 0; i < 50; i++) hash = md5(hash);
+	const key = hash.subarray(0, r >= 3 ? keyLen : 5);
+	let x = o.subarray(0, 32);
+	if (r <= 2) return rc4(key, x);
+	for (let i = 19; i >= 0; i--) x = rc4(xorKey(key, i), x);
+	return x;
+}
+function xorKey(key, i) {
+	return key.map((b) => b ^ i);
+}
+function userKeyR6(u, ue, password) {
 	if (u.length < 48 || ue.length < 32) return void 0;
 	const pw = passwordBytes(password);
 	const validationSalt = u.subarray(32, 40);
@@ -97,6 +120,14 @@ function deriveKeyR6(u, ue, password) {
 	const intermediate = hash2B(pw, keySalt, EMPTY);
 	return aesCbcDecrypt(intermediate, ZERO16, ue.subarray(0, 32), false);
 }
+function ownerKeyR6(o, u, oe, password) {
+	if (o.length < 48 || u.length < 48 || oe.length < 32) return void 0;
+	const pw = passwordBytes(password);
+	const udata = u.subarray(0, 48);
+	if (!equal(hash2B(pw, o.subarray(32, 40), udata), o.subarray(0, 32))) return void 0;
+	const intermediate = hash2B(pw, o.subarray(40, 48), udata);
+	return aesCbcDecrypt(intermediate, ZERO16, oe.subarray(0, 32), false);
+}
 function padPassword(password) {
 	const raw = strToBytes(password);
 	const out = /* @__PURE__ */ new Uint8Array(32);
@@ -123,19 +154,31 @@ function hash2B(pw, salt, udata) {
 	}
 	return k.subarray(0, 32);
 }
-function cipherMethod(encrypt, v) {
-	if (v < 4) return "rc4";
-	const stmf = encrypt.get("StmF");
-	const cfName = stmf instanceof PdfName ? stmf.value : "StdCF";
-	if (cfName === "Identity") return void 0;
-	const cf = encrypt.get("CF");
-	const cfDict = cf instanceof Map ? cf.get(cfName) : void 0;
-	const cfm = cfDict instanceof Map ? cfDict.get("CFM") : void 0;
-	if (cfm instanceof PdfName) {
-		if (cfm.value === "AESV2") return "aesv2";
-		if (cfm.value === "AESV3") return "aesv3";
-	}
-	return "rc4";
+function cryptMethods(encrypt, v, r) {
+	if (v < 4) return {
+		stream: "rc4",
+		string: "rc4"
+	};
+	const fallback = r >= 5 || v >= 5 ? "aesv3" : "rc4";
+	const methodOf = (key) => {
+		const named = encrypt.get(key);
+		const cfName = named instanceof PdfName ? named.value : "StdCF";
+		if (cfName === "Identity") return "none";
+		const cf = encrypt.get("CF");
+		const cfDict = cf instanceof Map ? cf.get(cfName) : void 0;
+		const cfm = cfDict instanceof Map ? cfDict.get("CFM") : void 0;
+		if (cfm instanceof PdfName) {
+			if (cfm.value === "AESV2") return "aesv2";
+			if (cfm.value === "AESV3") return "aesv3";
+			if (cfm.value === "V2") return "rc4";
+			if (cfm.value === "None") return "none";
+		}
+		return fallback;
+	};
+	return {
+		stream: methodOf("StmF"),
+		string: methodOf("StrF")
+	};
 }
 function objectKey(fileKey, objNum, gen, aes) {
 	const extra = aes ? AES_SALT : EMPTY;
@@ -150,6 +193,7 @@ function objectKey(fileKey, objNum, gen, aes) {
 	return md5(seed).subarray(0, Math.min(fileKey.length + 5, 16));
 }
 function decryptBytes(data, objNum, gen, fileKey, method) {
+	if (method === "none") return data;
 	if (method === "aesv3") {
 		if (data.length < 16) return data;
 		return aesCbcDecrypt(fileKey, data.subarray(0, 16), data.subarray(16), true);
@@ -161,18 +205,18 @@ function decryptBytes(data, objNum, gen, fileKey, method) {
 	}
 	return rc4(key, data);
 }
-function decryptValue(value, objNum, gen, fileKey, method) {
-	if (typeof value === "string") return latin1(decryptBytes(strToBytes(value), objNum, gen, fileKey, method));
-	if (value instanceof PdfHexString) return new PdfHexString(decryptBytes(value.bytes, objNum, gen, fileKey, method));
+function decryptValue(value, objNum, gen, fileKey, methods) {
+	if (typeof value === "string") return latin1(decryptBytes(strToBytes(value), objNum, gen, fileKey, methods.string));
+	if (value instanceof PdfHexString) return new PdfHexString(decryptBytes(value.bytes, objNum, gen, fileKey, methods.string));
 	if (value instanceof PdfStream) {
-		const dict = decryptValue(value.dict, objNum, gen, fileKey, method);
-		const data = decryptBytes(value.data, objNum, gen, fileKey, method);
+		const dict = decryptValue(value.dict, objNum, gen, fileKey, methods);
+		const data = decryptBytes(value.data, objNum, gen, fileKey, methods.stream);
 		return new PdfStream(dict instanceof Map ? dict : value.dict, data);
 	}
-	if (Array.isArray(value)) return value.map((v) => decryptValue(v, objNum, gen, fileKey, method));
+	if (Array.isArray(value)) return value.map((v) => decryptValue(v, objNum, gen, fileKey, methods));
 	if (value instanceof Map) {
 		const out = /* @__PURE__ */ new Map();
-		for (const [k, v] of value) out.set(k, decryptValue(v, objNum, gen, fileKey, method));
+		for (const [k, v] of value) out.set(k, decryptValue(v, objNum, gen, fileKey, methods));
 		return out;
 	}
 	return value;

package/dist/esm/pdf-reader/document.d.ts

@@ -35,6 +35,7 @@ export declare class PdfFile {
     private readonly cache;
     private readonly objStmCache;
     private decryptor;
+    private refused;
     private encryptObjNum;
     private constructor();
     /**
@@ -71,9 +72,14 @@ export declare class PdfFile {
     get catalog(): PdfDict;
     /**
      * The document is encrypted but no decryptor could be built (an unsupported
-     * handler, or a wrong/missing user password) — its content is unreadable.
+     * handler, or a refused password) — its content is unreadable.
      */
     get encryptionUnsupported(): boolean;
+    /**
+     * §7.6.3.4 — the document is encrypted and the password it was opened with is
+     * neither its user's nor its owner's, by the verifiers the file itself stores.
+     */
+    get passwordRefused(): boolean;
     /** The leaf pages, in document order, each with its inherited `/MediaBox` and `/Resources`. */
     pages(): Array<PdfPage>;
     /**

package/dist/esm/pdf-reader/document.js

@@ -31,6 +31,7 @@ var PdfFile = class PdfFile {
 	cache = /* @__PURE__ */ new Map();
 	objStmCache = /* @__PURE__ */ new Map();
 	decryptor;
+	refused;
 	encryptObjNum = -1;
 	constructor(buf, xref, trailer, filters = {}) {
 		this.buf = buf;
@@ -85,7 +86,9 @@ var PdfFile = class PdfFile {
 		const enc = this.resolve(encVal);
 		if (!(enc instanceof Map)) return;
 		const id = this.trailer.get("ID");
-		this.decryptor = buildDecryptor(enc, Array.isArray(id) ? id : void 0, password);
+		const built = buildDecryptor(enc, Array.isArray(id) ? id : void 0, password);
+		if ("decryptor" in built) this.decryptor = built.decryptor;
+		else this.refused = built.refused;
 	}
 	/** Resolve a stream's `/Length` when it is an indirect reference. */
 	lengthResolver = (r) => {
@@ -147,11 +150,18 @@ var PdfFile = class PdfFile {
 	}
 	/**
 	* The document is encrypted but no decryptor could be built (an unsupported
-	* handler, or a wrong/missing user password) — its content is unreadable.
+	* handler, or a refused password) — its content is unreadable.
 	*/
 	get encryptionUnsupported() {
 		return this.trailer.get("Encrypt") !== void 0 && this.decryptor === void 0;
 	}
+	/**
+	* §7.6.3.4 — the document is encrypted and the password it was opened with is
+	* neither its user's nor its owner's, by the verifiers the file itself stores.
+	*/
+	get passwordRefused() {
+		return this.refused === "password";
+	}
 	/** The leaf pages, in document order, each with its inherited `/MediaBox` and `/Resources`. */
 	pages() {
 		const out = [];

package/dist/esm/pdf-reader/reader.d.ts

@@ -14,11 +14,15 @@ import { FlowDoc } from '../core/ir/flow.js';
  * @param filters  Decoders for `/Filter` names this reader does not implement
  *                 (§7.4); see {@link StreamFilters}.
  * @returns The reconstructed FlowDoc and its accumulated {@link Loss} report.
+ * @throws WrongPasswordError when the file is encrypted and the password opens
+ *         it neither as its user nor as its owner — none given included.
  *
  * Which of the two readings a file gets is the FILE's to decide and no
  * caller's: a page that is mostly marks is reproduced where it stands, one
  * that is mostly lines is re-set as a document, and the reader records which
- * it chose. There is no override — see the note on {@link readingOf}.
+ * it chose. There is no override — see the note on {@link readingOf}. A file
+ * kept as a page also carries its `flowing` reading, for the one medium that
+ * can keep no page: see {@link ReadResult.flowing}.
  */
 export declare function readPdf(bytes: Uint8Array, password?: string, filters?: StreamFilters): ReadResult<FlowDoc>;
 /**

package/dist/esm/pdf-reader/reader.js

@@ -4,6 +4,7 @@ import { extractPageText } from "./text.js";
 import { collectPageVectors } from "./vector.js";
 import { reconstructByLayout } from "./layout.js";
 import { reconstructTaggedPdf } from "./tagged.js";
+import { WrongPasswordError } from "../core/crypto/password-error.js";
 //#region src/pdf-reader/reader.ts
 function sniffPdf(bytes) {
 	const limit = Math.min(bytes.length - 5, 1024);
@@ -41,30 +42,53 @@ function endsLikePdf(bytes) {
 * @param filters  Decoders for `/Filter` names this reader does not implement
 *                 (§7.4); see {@link StreamFilters}.
 * @returns The reconstructed FlowDoc and its accumulated {@link Loss} report.
+* @throws WrongPasswordError when the file is encrypted and the password opens
+*         it neither as its user nor as its owner — none given included.
 *
 * Which of the two readings a file gets is the FILE's to decide and no
 * caller's: a page that is mostly marks is reproduced where it stands, one
 * that is mostly lines is re-set as a document, and the reader records which
-* it chose. There is no override — see the note on {@link readingOf}.
+* it chose. There is no override — see the note on {@link readingOf}. A file
+* kept as a page also carries its `flowing` reading, for the one medium that
+* can keep no page: see {@link ReadResult.flowing}.
 */
 function readPdf(bytes, password = "", filters = {}) {
 	const file = PdfFile.parse(bytes, password, filters);
+	if (file.passwordRefused) throw new WrongPasswordError(password === "" ? "This PDF needs a password to open — pass it as `password`" : "The password opens this PDF neither as its user nor as its owner");
+	const { reading, forText } = readingOf(file);
+	const read = readAs(file, reading);
+	if (!forText) return read;
+	return {
+		...read,
+		flowing: () => readAs(PdfFile.parse(bytes, password, filters), "flow", true)
+	};
+}
+/**
+* The file read the one way: the losses every reading reports, the reading's
+* own, and its reconstruction.
+*
+* @param file     The parsed file.
+* @param reading  Whether the words re-set as a document or stand where drawn.
+* @param reflowed Whether this is the flowing reading of a file the reader
+*                 keeps as a page, for a medium that places nothing.
+* @returns The reconstructed FlowDoc and its losses.
+*/
+function readAs(file, reading, reflowed = false) {
 	const losses = [];
 	if (file.encryptionUnsupported) losses.push({
 		severity: "dropped",
 		feature: FEATURES.text,
-		detail: "encrypted PDF — the user password was missing or incorrect, or the handler is unsupported"
+		detail: "encrypted PDF — its security handler is not supported, or its /Encrypt dictionary cannot be read, so its content cannot be decrypted"
 	});
 	for (const name of file.unknownFilters) losses.push({
 		severity: "dropped",
 		feature: FEATURES.text,
 		detail: `PDF stream filter /${name} is not supported; streams using it are unreadable`
 	});
-	const reading = readingOf(file);
 	losses.push({
 		severity: "degraded",
 		feature: FEATURES.text,
-		detail: reading === "positional" ? "PDF read as a PAGE (placed): its artwork outweighs its prose, so every line stands where its glyphs stand" : "PDF read as a DOCUMENT (flowing): its prose outweighs its artwork, so the words re-set and the artwork takes its turn in reading order"
+		detail: reflowed ? "PDF read as a DOCUMENT (flowing) for a medium that keeps only the text: the file is kept as a PAGE elsewhere for its drawn letters or its rules, which only a page can show where they stand" : reading === "positional" ? "PDF read as a PAGE (placed): its artwork outweighs its prose, so every line stands where its glyphs stand" : "PDF read as a DOCUMENT (flowing): its prose outweighs its artwork, so the words re-set and the artwork takes its turn in reading order"
 	});
 	const tagged = reading === "positional" ? void 0 : reconstructTaggedPdf(file);
 	const reconstruction = tagged ?? reconstructByLayout(file, reading);
@@ -94,7 +118,12 @@ function readPdf(bytes, password = "", filters = {}) {
 * folded into a report does not make the report a plan.
 *
 * A threshold is a guess, and this one is stated rather than hidden: the reader
-* records which reading it took and why, and the caller can name the other.
+* records which reading it took and why.
+*
+* A glyph the file names no character for is drawn, and counted as a mark like
+* any other path — it IS one, for every medium that has to place it; so is a
+* rule. Whether the page was a page for those alone is said as well: see
+* `forText`.
 */
 function readingOf(file) {
 	/**
@@ -112,14 +141,28 @@ function readingOf(file) {
 	const DRAWN = 2;
 	/** Below this many runs, an angle is a stamp or a watermark and not the page. */
 	const ENOUGH_TURNED = 8;
+	/**
+	* How many rules a page may have for each mark of other artwork and still be
+	* a ruled document: an estimate shades its heading row and its total, and a
+	* dozen shaded cells under eighty rules are a table's, not a drawing's.
+	*/
+	const RULES_PER_MARK = 4;
 	const ratios = [];
+	/** The same, the drawn letters left out. */
+	const artwork = [];
+	const ratioOf = (marks, lines) => marks < ENOUGH_MARKS ? 0 : lines > 0 ? marks / lines : DRAWN;
 	for (const page of file.pages()) {
 		let marks = 0;
+		let letters = 0;
+		let rules = 0;
 		let lines = 0;
 		let turned = 0;
 		let runs = 0;
 		try {
-			marks = collectPageVectors(file, page, []).vectors.length;
+			const vectors = collectPageVectors(file, page, []).vectors;
+			marks = vectors.length;
+			letters = vectors.filter((v) => v.glyph === true).length;
+			rules = vectors.filter(isRule).length;
 			const ys = /* @__PURE__ */ new Set();
 			for (const run of extractPageText(file, page)) {
 				ys.add(Math.round(run.y));
@@ -132,17 +175,41 @@ function readingOf(file) {
 		}
 		if (runs >= ENOUGH_TURNED && turned > runs * .5) {
 			ratios.push(DRAWN);
+			artwork.push(DRAWN);
 			continue;
 		}
-		if (marks < ENOUGH_MARKS) {
-			ratios.push(0);
-			continue;
-		}
-		ratios.push(lines > 0 ? marks / lines : DRAWN);
+		ratios.push(ratioOf(marks, lines));
+		const ruled = lines > 0 && marks - letters - rules < Math.max(ENOUGH_MARKS, rules / RULES_PER_MARK);
+		artwork.push(ruled ? 0 : ratioOf(marks - letters, lines));
 	}
-	if (ratios.length === 0) return "flow";
-	const sorted = [...ratios].sort((a, b) => a - b);
-	return (sorted[Math.floor(sorted.length / 2)] ?? 0) >= DRAWN ? "positional" : "flow";
+	const drawn = (rs) => {
+		const sorted = [...rs].sort((a, b) => a - b);
+		return (sorted[Math.floor(sorted.length / 2)] ?? 0) >= DRAWN;
+	};
+	if (!drawn(ratios)) return {
+		reading: "flow",
+		forText: false
+	};
+	return {
+		reading: "positional",
+		forText: !drawn(artwork)
+	};
+}
+/** Thinner than this a straight mark is a line, whatever it was drawn as. */
+var RULE_THICKNESS = 2.5;
+/** …and it is a rule rather than a dot or a tick from this long. */
+var RULE_LENGTH = 4;
+/**
+* Whether a painted path is a RULE: straight, along the page, a line thin
+* enough to be one — stroked as a line or filled as a hairline box, which is
+* how many producers draw a table's grid.
+*/
+function isRule(v) {
+	if (v.glyph === true || v.gradient !== void 0) return false;
+	if (v.segs.some((seg) => seg.op === "cubic")) return false;
+	const w = v.maxX - v.minX;
+	const h = v.maxY - v.minY;
+	return Math.min(w, h) <= RULE_THICKNESS && Math.max(w, h) >= RULE_LENGTH;
 }
 /**
 * The `pdfReader` adapter: a {@link DocumentReader} that sniffs the `%PDF-`

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "reamkit",
-  "version": "1.33.0",
+  "version": "1.33.1",
   "description": "Ream — convert DOCX, XLSX, PPTX, PDF and legacy DOC, XLS and PPT to PDF, SVG, HTML, Markdown, DOCX and XLSX, built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
   "license": "MIT",
-  "author": "Alex Krassavin <info@reamkit.dev>",
+  "author": "Alexandr Krassavin <info@reamkit.dev>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/alex-krassavin/reamkit.git"