reamkit 1.22.0 → 1.24.0

package/dist/esm/core/bmp.d.ts

@@ -0,0 +1,33 @@
+/** One decoded bitmap: chunky 8-bit samples, plus alpha when the file carries it. */
+export interface DecodedBmp {
+    readonly width: number;
+    readonly height: number;
+    /** Row-major RGB samples, `width * height * 3` long. */
+    readonly data: Uint8Array;
+    /** One byte per pixel, present only when the file states real transparency. */
+    readonly alpha?: Uint8Array;
+    /** `biXPelsPerMeter`/`biYPelsPerMeter` turned into pixels per inch. */
+    readonly dpiX?: number;
+    readonly dpiY?: number;
+}
+/** Whether these bytes open with the `BM` signature of a bitmap FILE. */
+export declare function isBmp(bytes: Uint8Array): boolean;
+/**
+ * MS-ODRAW §2.2.28 — a `BlipDIB`'s payload is a bitmap without its 14-byte
+ * BITMAPFILEHEADER, which the Escher record makes redundant. Put it back.
+ *
+ * @param dib The bytes from the DIB header onwards.
+ * @returns A complete BMP file, or `undefined` when the header does not read
+ *          as a bitmap at all.
+ */
+export declare function dibToBmp(dib: Uint8Array): Uint8Array | undefined;
+/**
+ * Decode a Windows bitmap into 8-bit RGB samples.
+ *
+ * @param bytes A complete BMP file (`BM` signature included).
+ * @returns The samples, their size and any alpha channel.
+ * @throws Error when the file is malformed, or carries a bitmap this does not
+ *         read — a JPEG or PNG smuggled inside a DIB (`BI_JPEG`/`BI_PNG`),
+ *         which is a whole other file wearing a bitmap header.
+ */
+export declare function decodeBmp(bytes: Uint8Array): DecodedBmp;

package/dist/esm/core/bmp.js

@@ -0,0 +1,276 @@
+//#region src/core/bmp.ts
+var FILE_HEADER_BYTES = 14;
+var CORE_HEADER_BYTES = 12;
+var INFO_HEADER_BYTES = 40;
+var MAX_PIXELS = 4e7;
+var BI_RGB = 0;
+var BI_RLE8 = 1;
+var BI_RLE4 = 2;
+var BI_BITFIELDS = 3;
+var BI_ALPHABITFIELDS = 6;
+/** Whether these bytes open with the `BM` signature of a bitmap FILE. */
+function isBmp(bytes) {
+	return bytes.length >= FILE_HEADER_BYTES && bytes[0] === 66 && bytes[1] === 77;
+}
+/**
+* MS-ODRAW §2.2.28 — a `BlipDIB`'s payload is a bitmap without its 14-byte
+* BITMAPFILEHEADER, which the Escher record makes redundant. Put it back.
+*
+* @param dib The bytes from the DIB header onwards.
+* @returns A complete BMP file, or `undefined` when the header does not read
+*          as a bitmap at all.
+*/
+function dibToBmp(dib) {
+	const head = readDibHeader(dib, 0);
+	if (!head) return void 0;
+	const offBits = FILE_HEADER_BYTES + head.headerBytes + head.maskBytes + head.paletteBytes;
+	const out = new Uint8Array(FILE_HEADER_BYTES + dib.length);
+	const view = new DataView(out.buffer);
+	out[0] = 66;
+	out[1] = 77;
+	view.setUint32(2, out.length, true);
+	view.setUint32(10, offBits, true);
+	out.set(dib, FILE_HEADER_BYTES);
+	return out;
+}
+/**
+* Decode a Windows bitmap into 8-bit RGB samples.
+*
+* @param bytes A complete BMP file (`BM` signature included).
+* @returns The samples, their size and any alpha channel.
+* @throws Error when the file is malformed, or carries a bitmap this does not
+*         read — a JPEG or PNG smuggled inside a DIB (`BI_JPEG`/`BI_PNG`),
+*         which is a whole other file wearing a bitmap header.
+*/
+function decodeBmp(bytes) {
+	if (!isBmp(bytes)) throw new Error("BMP: not a bitmap");
+	const file = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const head = readDibHeader(bytes, FILE_HEADER_BYTES);
+	if (!head) throw new Error("BMP: unreadable header");
+	const { width, height, topDown, bitCount, compression } = head;
+	if (width <= 0 || height <= 0) throw new Error("BMP: empty bitmap");
+	if (width * height > MAX_PIXELS) throw new Error("BMP: image too large");
+	if (compression === 4 || compression === 5) throw new Error("BMP: embedded JPEG/PNG bitmaps are not supported");
+	const stated = file.getUint32(10, true);
+	const computed = FILE_HEADER_BYTES + head.headerBytes + head.maskBytes + head.paletteBytes;
+	const pixelsAt = stated >= computed && stated < bytes.length ? stated : computed;
+	const palette = readPalette(bytes, FILE_HEADER_BYTES + head.headerBytes, head);
+	const count = width * height;
+	const data = new Uint8Array(count * 3);
+	const rowOf = (y) => topDown ? y : height - 1 - y;
+	if (compression === BI_RLE8 || compression === BI_RLE4) {
+		const indices = decodeRle(bytes.subarray(pixelsAt), width, height, compression === BI_RLE4);
+		for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+			const at = (rowOf(y) * width + x) * 3;
+			const p = (indices[y * width + x] ?? 0) * 3;
+			data[at] = palette[p] ?? 0;
+			data[at + 1] = palette[p + 1] ?? 0;
+			data[at + 2] = palette[p + 2] ?? 0;
+		}
+		return {
+			width,
+			height,
+			data,
+			...density(head)
+		};
+	}
+	const stride = ((width * bitCount + 31) / 32 | 0) * 4;
+	const alpha = head.alphaMask !== 0 ? new Uint8Array(count) : void 0;
+	const shifts = {
+		r: maskShift(head.redMask),
+		g: maskShift(head.greenMask),
+		b: maskShift(head.blueMask),
+		a: maskShift(head.alphaMask)
+	};
+	for (let y = 0; y < height; y++) {
+		const row = pixelsAt + y * stride;
+		if (row + stride > bytes.length + stride) break;
+		for (let x = 0; x < width; x++) {
+			const at = (rowOf(y) * width + x) * 3;
+			if (bitCount <= 8) {
+				const p = paletteIndex(bytes, row, x, bitCount) * 3;
+				data[at] = palette[p] ?? 0;
+				data[at + 1] = palette[p + 1] ?? 0;
+				data[at + 2] = palette[p + 2] ?? 0;
+				continue;
+			}
+			if (bitCount === 24) {
+				const o = row + x * 3;
+				data[at] = bytes[o + 2] ?? 0;
+				data[at + 1] = bytes[o + 1] ?? 0;
+				data[at + 2] = bytes[o] ?? 0;
+				continue;
+			}
+			const raw = bitCount === 16 ? (bytes[row + x * 2] ?? 0) | (bytes[row + x * 2 + 1] ?? 0) << 8 : ((bytes[row + x * 4] ?? 0) | (bytes[row + x * 4 + 1] ?? 0) << 8 | (bytes[row + x * 4 + 2] ?? 0) << 16 | (bytes[row + x * 4 + 3] ?? 0) << 24) >>> 0;
+			data[at] = channel(raw, head.redMask, shifts.r);
+			data[at + 1] = channel(raw, head.greenMask, shifts.g);
+			data[at + 2] = channel(raw, head.blueMask, shifts.b);
+			if (alpha) alpha[rowOf(y) * width + x] = channel(raw, head.alphaMask, shifts.a);
+		}
+	}
+	const opaque = alpha?.every((v) => v === 0) ?? true;
+	return {
+		width,
+		height,
+		data,
+		...alpha && !opaque ? { alpha } : {},
+		...density(head)
+	};
+}
+function readDibHeader(bytes, at) {
+	if (bytes.length < at + 4) return void 0;
+	const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const headerBytes = v.getUint32(at, true);
+	const core = headerBytes === CORE_HEADER_BYTES;
+	if (!core && headerBytes < INFO_HEADER_BYTES) return void 0;
+	if (bytes.length < at + headerBytes) return void 0;
+	const width = core ? v.getInt16(at + 4, true) : v.getInt32(at + 4, true);
+	const rawHeight = core ? v.getInt16(at + 6, true) : v.getInt32(at + 8, true);
+	const planes = core ? v.getUint16(at + 6, true) : v.getUint16(at + 12, true);
+	const bitCount = core ? v.getUint16(at + 8, true) : v.getUint16(at + 14, true);
+	const compression = core ? BI_RGB : v.getUint32(at + 16, true);
+	if (planes !== 1) return void 0;
+	if (![
+		1,
+		2,
+		4,
+		8,
+		16,
+		24,
+		32
+	].includes(bitCount)) return void 0;
+	if (compression > 6) return void 0;
+	if (width <= 0 || rawHeight === 0) return void 0;
+	const clrUsed = core ? 0 : v.getUint32(at + 32, true);
+	const inHeader = headerBytes >= 52;
+	const maskBytes = !inHeader && (compression === BI_BITFIELDS || compression === BI_ALPHABITFIELDS) ? compression === BI_ALPHABITFIELDS ? 16 : 12 : 0;
+	const maskAt = inHeader ? at + 40 : at + headerBytes;
+	const stated = compression === BI_BITFIELDS || compression === BI_ALPHABITFIELDS || inHeader;
+	const readMask = (i) => stated && bytes.length >= maskAt + (i + 1) * 4 ? v.getUint32(maskAt + i * 4, true) : 0;
+	const defaults = bitCount === 16 ? [
+		31744,
+		992,
+		31
+	] : [
+		16711680,
+		65280,
+		255
+	];
+	const red = readMask(0) || defaults[0];
+	const green = readMask(1) || defaults[1];
+	const blue = readMask(2) || defaults[2];
+	const alphaMask = headerBytes >= 56 && bytes.length >= maskAt + 16 ? v.getUint32(maskAt + 12, true) : 0;
+	const paletteEntryBytes = core ? 3 : 4;
+	return {
+		headerBytes,
+		maskBytes,
+		paletteBytes: (bitCount <= 8 ? clrUsed || 1 << bitCount : 0) * paletteEntryBytes,
+		paletteEntryBytes,
+		width,
+		height: Math.abs(rawHeight),
+		topDown: rawHeight < 0,
+		bitCount,
+		compression,
+		redMask: red,
+		greenMask: green,
+		blueMask: blue,
+		alphaMask,
+		pxPerMeterX: core ? 0 : v.getInt32(at + 24, true),
+		pxPerMeterY: core ? 0 : v.getInt32(at + 28, true)
+	};
+}
+/** The palette as flat RGB triples, whichever entry width the header uses. */
+function readPalette(bytes, at, head) {
+	const entries = head.paletteBytes / head.paletteEntryBytes;
+	const out = new Uint8Array(entries * 3);
+	for (let i = 0; i < entries; i++) {
+		const o = at + i * head.paletteEntryBytes;
+		out[i * 3] = bytes[o + 2] ?? 0;
+		out[i * 3 + 1] = bytes[o + 1] ?? 0;
+		out[i * 3 + 2] = bytes[o] ?? 0;
+	}
+	return out;
+}
+/** The palette index of one pixel of a 1/2/4/8-bit row. */
+function paletteIndex(bytes, row, x, bitCount) {
+	if (bitCount === 8) return bytes[row + x] ?? 0;
+	const perByte = 8 / bitCount;
+	return (bytes[row + (x / perByte | 0)] ?? 0) >> 8 - bitCount * (x % perByte + 1) & (1 << bitCount) - 1;
+}
+/** How far right a mask's field sits, so its bits can be read off. */
+function maskShift(mask) {
+	if (mask === 0) return 0;
+	let shift = 0;
+	while ((mask >>> shift & 1) === 0) shift++;
+	return shift;
+}
+/** One channel of a packed pixel, stretched to the full byte range. */
+function channel(raw, mask, shift) {
+	if (mask === 0) return 0;
+	const width = (mask >>> shift).toString(2).length;
+	const value = (raw & mask) >>> shift;
+	const max = (1 << width) - 1;
+	return max === 0 ? 0 : Math.round(value * 255 / max);
+}
+/** §biXPelsPerMeter — the resolution the bitmap claims, in pixels per inch. */
+function density(head) {
+	if (head.pxPerMeterX <= 0 || head.pxPerMeterY <= 0) return {};
+	return {
+		dpiX: head.pxPerMeterX * .0254,
+		dpiY: head.pxPerMeterY * .0254
+	};
+}
+/**
+* §BI_RLE8 / §BI_RLE4 — run-length rows of palette indices.
+*
+* Each pair is either a run (a non-zero count and the index to repeat) or an
+* escape (a zero count and a code): 0 ends the row, 1 ends the bitmap, 2 is a
+* delta that skips forward, and anything else is that many literal pixels,
+* padded to a two-byte boundary.
+*
+* @param data   The bytes from the first run onwards.
+* @param width  The bitmap's width in pixels.
+* @param height Its height in rows.
+* @param four   Whether this is the four-bit form, which packs two indices per byte.
+* @returns One palette index per pixel, top row first.
+*/
+function decodeRle(data, width, height, four) {
+	const out = new Uint8Array(width * height);
+	let x = 0;
+	let y = 0;
+	let at = 0;
+	const put = (index) => {
+		if (x < width && y < height) out[y * width + x] = index;
+		x++;
+	};
+	while (at + 1 < data.length && y < height) {
+		const count = data[at];
+		const value = data[at + 1];
+		at += 2;
+		if (count > 0) {
+			for (let i = 0; i < count; i++) put(four ? i % 2 === 0 ? value >> 4 : value & 15 : value);
+			continue;
+		}
+		if (value === 0) {
+			x = 0;
+			y++;
+			continue;
+		}
+		if (value === 1) break;
+		if (value === 2) {
+			x += data[at] ?? 0;
+			y += data[at + 1] ?? 0;
+			at += 2;
+			continue;
+		}
+		const bytesUsed = four ? (value + 1) / 2 | 0 : value;
+		for (let i = 0; i < value; i++) {
+			const byte = data[at + (four ? i / 2 | 0 : i)] ?? 0;
+			put(four ? i % 2 === 0 ? byte >> 4 : byte & 15 : byte);
+		}
+		at += bytesUsed + bytesUsed % 2;
+	}
+	return out;
+}
+//#endregion
+export { decodeBmp, dibToBmp, isBmp };

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

@@ -143,6 +143,22 @@ export declare class Ream {
      * @returns The font bytes and, for docx, optional per-family registries.
      */
     private resolveFonts;
+    /**
+     * Fetch one face per writing system the document holds text in — the curated
+     * families are Latin, and Han, Kana, Hangul, Arabic and the geometric symbols
+     * are a notdef box in every one of them.
+     *
+     * Only the regular weight is fetched: Noto Sans SC is ten megabytes, and a
+     * bold run in it is better stroked (see `SyntheticFace`) than downloaded four
+     * times over. A face that fails to arrive is a recorded loss, not a throw —
+     * the rest of the document still renders.
+     *
+     * @param into    The registry map the run resolver looks in.
+     * @param flow    The parsed document.
+     * @param options The convert options (for the injectable `fetch`).
+     * @param losses  Where a face that could not be fetched records itself.
+     */
+    private addScriptFonts;
     /**
      * In strict mode, throw {@link ConversionLossError} for the first recorded loss.
      *

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

@@ -1,4 +1,5 @@
-import { fetchFontSet } from "../fonts/remote-fonts.js";
+import { fetchFontSet, fetchScriptFont, resolveFamilyKey } from "../fonts/remote-fonts.js";
+import { scriptsInFlow } from "../fonts/scripts.js";
 import { FontRegistry } from "../font/font-registry.js";
 import { createFontMeasure } from "../font/measure.js";
 import { ConversionLossError } from "../ir/loss.js";
@@ -12,8 +13,8 @@ import { writeDocx } from "../../word/docx-writer.js";
 import { writeXlsx } from "../../excel/xlsx-writer.js";
 import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
-import { resolveDocxAutoFonts } from "../../word/docx-to-pdf.js";
 import { DEFAULT_READERS, resolveFontsViaChain, toFlowDoc } from "./facade.js";
+import { familiesInFlow } from "../fonts/families.js";
 import { decryptPackage, isEncryptedPackage } from "../crypto/offcrypto.js";
 //#region src/core/converter/ream.ts
 /**
@@ -150,7 +151,7 @@ var Ream = class Ream {
 				losses
 			};
 		}
-		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses);
+		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses, flow);
 		const registry = FontRegistry.fromBytes(fonts);
 		const paginated = this.sheet ? projectSheetDoc(this.sheet, {
 			...options.now ? { now: options.now } : {},
@@ -209,7 +210,7 @@ var Ream = class Ream {
 	* @param losses  The mutable loss list a substitution is appended to.
 	* @returns The font bytes and, for docx, optional per-family registries.
 	*/
-	async resolveFonts(options, losses) {
+	async resolveFonts(options, losses, flow) {
 		const explicit = options.fonts ?? (options.fontBytes ? { regular: options.fontBytes } : void 0);
 		if (explicit) return { fonts: explicit };
 		if (options.fontProviders && options.fontProviders.length > 0) {
@@ -217,11 +218,60 @@ var Ream = class Ream {
 			if (loss) losses.push(loss);
 			if (fonts) return { fonts };
 		}
-		if (this.readerId === "docx") return resolveDocxAutoFonts(this.source, options);
-		return { fonts: await fetchFontSet({
-			...options.fontFamily ? { family: options.fontFamily } : {},
-			...options.fontFetch ? { fetch: options.fontFetch } : {}
-		}) };
+		const fetchOpt = options.fontFetch ? { fetch: options.fontFetch } : {};
+		const keys = options.fontFamily ? new Set([resolveFamilyKey(options.fontFamily)]) : familiesInFlow(flow);
+		if (keys.size <= 1 && scriptsInFlow(flow).scripts.size === 0) {
+			const family = keys.values().next().value;
+			return { fonts: await fetchFontSet({
+				...family ? { family } : {},
+				...fetchOpt
+			}) };
+		}
+		const registriesByFamily = /* @__PURE__ */ new Map();
+		let baseBytes;
+		for (const key of keys) {
+			const bytes = await fetchFontSet({
+				family: key,
+				...fetchOpt
+			});
+			registriesByFamily.set(key, FontRegistry.fromBytes(bytes));
+			if (key === "arimo" || !baseBytes) baseBytes = bytes;
+		}
+		await this.addScriptFonts(registriesByFamily, flow, options, losses);
+		return {
+			fonts: baseBytes,
+			registriesByFamily
+		};
+	}
+	/**
+	* Fetch one face per writing system the document holds text in — the curated
+	* families are Latin, and Han, Kana, Hangul, Arabic and the geometric symbols
+	* are a notdef box in every one of them.
+	*
+	* Only the regular weight is fetched: Noto Sans SC is ten megabytes, and a
+	* bold run in it is better stroked (see `SyntheticFace`) than downloaded four
+	* times over. A face that fails to arrive is a recorded loss, not a throw —
+	* the rest of the document still renders.
+	*
+	* @param into    The registry map the run resolver looks in.
+	* @param flow    The parsed document.
+	* @param options The convert options (for the injectable `fetch`).
+	* @param losses  Where a face that could not be fetched records itself.
+	*/
+	async addScriptFonts(into, flow, options, losses) {
+		const { scripts } = scriptsInFlow(flow);
+		for (const script of scripts) {
+			const bytes = await fetchScriptFont(script, options.fontFetch);
+			if (!bytes) {
+				losses.push({
+					feature: "font",
+					detail: `no face could be fetched for the ${script} script; its text draws as boxes`,
+					severity: "substituted"
+				});
+				continue;
+			}
+			into.set(script, FontRegistry.fromBytes(bytes));
+		}
 	}
 	/**
 	* In strict mode, throw {@link ConversionLossError} for the first recorded loss.

package/dist/esm/core/document-model/types.d.ts

@@ -787,6 +787,13 @@ export interface CellProperties {
      * is a word-processor table's default.
      */
     readonly verticalAlign?: 'top' | 'center' | 'bottom';
+    /**
+     * §17.4.71 `w:textDirection` / §21.1.3.17 `a:tcPr@vert` — the cell's text is
+     * turned a quarter: `vert` reads top-to-bottom (turned clockwise), `vert270`
+     * bottom-to-top. Its lines then run along the cell's HEIGHT and stack across
+     * its width, which is what makes a narrow header column readable.
+     */
+    readonly textDirection?: 'vert' | 'vert270';
 }
 /** §17.4.81 `w:trPr` — a table row's properties: height, split/header flags. */
 export interface RowProperties {
@@ -1025,6 +1032,34 @@ export interface ShapeFill {
      * text box: stretched, such a fill is a blur where it should be a pattern.
      */
     readonly tiled?: boolean;
+    /**
+     * The size ONE copy of a tiled fill occupies, when the shape states it —
+     * MS-ODRAW §2.3.7.11/.12 `fillWidth` / `fillHeight`. Absent, a tile is the
+     * picture at its own resolution, which is the default both formats give.
+     */
+    readonly tileSizePt?: {
+        readonly widthPt: number;
+        readonly heightPt: number;
+    };
+    /**
+     * §20.1.8.58 `a:tile @sx @sy` — how far the picture is scaled BEFORE it is
+     * repeated, as fractions of its own size (1 = 100 %). A texture halved tiles
+     * four times as often, and read as a plain repeat it tiles once.
+     */
+    readonly tileScale?: {
+        readonly sx: number;
+        readonly sy: number;
+    };
+    /**
+     * Where the grid of copies is anchored. DrawingML pins it to the shape's
+     * top-left corner (§20.1.8.58 `a:tile @algn`, which defaults to `tl`); an
+     * MS-ODRAW texture fill (§2.3.7.13 `fillOriginX`/`fillOriginY`, both
+     * defaulting to nothing) centres it on the shape instead. It only shows when
+     * the copies do not divide the box evenly — and it shows most when ONE copy
+     * is larger than the box, where the difference is which part of the picture
+     * is visible at all.
+     */
+    readonly tileFromCentre?: boolean;
     /**
      * §20.1.8.14 `a:blipFill` — the picture painted across the shape's box. A
      * DrawingML picture IS a shape with one of these, which is how a `pic:pic`
@@ -1144,6 +1179,26 @@ export interface ShapeTextBody {
      * WordArt is set at whatever size fills the box it was drawn in.
      */
     readonly fitToBox?: boolean;
+    /**
+     * §20.1.9.10 `a:prstTxWarp` — DrawingML WordArt: the preset curve the text is
+     * bent through, and the `a:avLst` `adj` guide when the file states one. The
+     * warped text does not wrap and is stretched to fill the shape's box, so the
+     * size its runs state stops deciding how large it is drawn. `textNoShape` is
+     * not carried: it is the enumeration's "no warp" member, and a body under it
+     * is an ordinary text box.
+     */
+    readonly warp?: {
+        readonly preset: string;
+        readonly adjust?: number;
+    };
+    /**
+     * §20.1.10.42 `a:normAutofit` — the text SHRINKS to fit the box, and only
+     * shrinks: a size that already fits is left alone. PowerPoint writes the
+     * scale it settled on into `@fontScale` and that is applied at parse; this
+     * is for the text that arrives without one, which is every box of a diagram
+     * laid out from its layout part rather than from a cached drawing.
+     */
+    readonly shrinkToFit?: boolean;
     /**
      * `wps:txbx @id` / `wps:linkedTxbx @id @seq` — the chain of boxes this one
      * belongs to. Text that overruns a box continues in the next of its chain;

package/dist/esm/core/drawingml/chart-geometry.js

@@ -46,7 +46,7 @@ function niceScale(dataMin, dataMax, maxTicks = 6) {
 	const lo = Math.min(dataMin, dataMax);
 	let hi = Math.max(dataMin, dataMax);
 	if (lo === hi) hi = lo + 1;
-	const step = niceNum(niceNum(hi - lo, false) / Math.max(1, maxTicks - 1), true);
+	const step = niceNum((hi - lo) / Math.max(1, maxTicks - 1), true);
 	const headroom = hi > 0 ? hi * 1.05 : hi;
 	return {
 		min: Math.floor(lo / step) * step,
@@ -712,11 +712,17 @@ function autoRange(vals) {
 	return [lo > 0 && lo < 5 / 6 * hi ? 0 : lo, hi];
 }
 /**
-* Ticks that fit along an axis `extentPt` long (mirrors {@link axisScale}).
-* A tick every 32pt is what both references draw: at 24 a 250pt plot carried
-* eleven of them (0, 0.5, 1 … 5.5) where both label 0…6 in whole numbers.
+* How many ticks an axis `extentPt` long carries (mirrors {@link axisScale}).
+*
+* A tall axis takes more of them — a fixed six drew 0/100/200/300 down a plot
+* where both references fit 0/50/…/300 — but the appetite is milder than it
+* looks: asked for one every 32pt, a 427pt chart wanted ten, and Excel labels
+* that chart's 0…5 data 0/1/…/6 where we drew half-steps (chart-texture-bg
+* .pptx). One per ~48pt and never more than eight satisfies both, now that
+* {@link niceScale} measures its step against the range the data spans rather
+* than against Heckbert's rounded-up one.
 */
-var tickBudget = (extentPt) => Math.min(10, Math.max(4, Math.round(extentPt / 32)));
+var tickBudget = (extentPt) => Math.min(8, Math.max(4, Math.round(extentPt / 48)));
 /** Side (points) of the square stamped for a series that names no symbol. */
 var DEFAULT_MARKER_PT = 4;
 /**
@@ -869,9 +875,10 @@ function buildPieScene(chart, wPt, hPt, measure) {
 		});
 		const mid = ang + sweep / 2;
 		const pct = Math.round(v / total * 100);
+		const own = chart.showValues ? fmtDataLabel(chart, v) : `${pct}%`;
 		const custom = series.pointLabels?.find((l) => l.idx === i)?.text;
-		if (custom !== void 0 || pct >= 5) labels.push({
-			text: custom ?? `${pct}%`,
+		if (custom !== void 0 || chart.showValues || pct >= 5) labels.push({
+			text: custom ?? own,
 			x: cx + Math.cos(mid) * labelR,
 			y: cy + Math.sin(mid) * labelR - 9 / 3,
 			sizePt: 9,

package/dist/esm/core/drawingml/colors.d.ts

@@ -3,10 +3,12 @@ import { PoNode } from '../po-helpers.js';
  * A colour transform child (§20.1.2.3): `lumMod`/`lumOff` modulate luminance,
  * `shade` darkens toward black, `tint` lightens toward white. `val` is normalised
  * to 0..1 (the XML stores thousandths of a percent). `alpha` composites over white
- * (solid fills emit no transparency).
+ * (solid fills emit no transparency). `gamma`/`invGamma` carry no value: they
+ * shift the colour into the other light and back, which changes what the
+ * transforms between them mean.
  */
 export interface ColorMod {
-    readonly kind: 'lumMod' | 'lumOff' | 'shade' | 'tint' | 'alpha' | 'satMod' | 'hueMod' | 'hueOff' | 'satOff';
+    readonly kind: 'lumMod' | 'lumOff' | 'shade' | 'tint' | 'alpha' | 'satMod' | 'hueMod' | 'hueOff' | 'satOff' | 'gamma' | 'invGamma';
     readonly val: number;
 }
 /**

package/dist/esm/core/drawingml/colors.js

@@ -99,6 +99,13 @@ function applyColorMods(hex, mods) {
 		r = toSrgb(toLinear(r) * m.val + (1 - m.val));
 		g = toSrgb(toLinear(g) * m.val + (1 - m.val));
 		b = toSrgb(toLinear(b) * m.val + (1 - m.val));
+	} else if (m.kind === "gamma" || m.kind === "invGamma") {
+		const shift = m.kind === "gamma" ? toSrgb : toLinear;
+		[r, g, b] = [
+			shift(r),
+			shift(g),
+			shift(b)
+		];
 	} else if (m.kind === "lumMod" || m.kind === "lumOff") {
 		const [h, s, l] = rgbToHsl(r, g, b);
 		const l2 = m.kind === "lumMod" ? l * m.val : clamp01(l + m.val);
@@ -230,6 +237,14 @@ function readColorMods(colorNode) {
 				val: v / 1e5
 			});
 		}
+		if (poIs(c, "a:gamma")) mods.push({
+			kind: "gamma",
+			val: 0
+		});
+		if (poIs(c, "a:invGamma")) mods.push({
+			kind: "invGamma",
+			val: 0
+		});
 		if (poIs(c, "a:hueOff")) {
 			const v = poIntAttr(c, "val");
 			if (v !== void 0) mods.push({

package/dist/esm/core/drawingml/diagram/colors.d.ts

@@ -0,0 +1,52 @@
+import { PoNode } from '../../po-helpers.js';
+/** The colours part, as the drawing writer asks it. */
+export declare class DiagramColors {
+    private readonly byLabel;
+    constructor(tree: ReadonlyArray<PoNode>);
+    /**
+     * The `a:solidFill` for a box, or undefined when the part states none.
+     *
+     * @param label The layout node's `styleLbl`.
+     * @param index The box's place in the run of siblings.
+     */
+    fill(label: string | undefined, index: number): string | undefined;
+    /**
+     * Whether the part states this label at all.
+     *
+     * A label it names but gives no fill — `revTx`, the reversed text of a
+     * process arrow — is a box with NO fill, which is not the same as a file
+     * that ships no colours and falls back to one accent for everything.
+     */
+    knows(label: string | undefined): boolean;
+    /**
+     * The `a:ln` for a box's OUTLINE, where the part states one.
+     *
+     * A follower box is often a near-white wash with the node's own accent drawn
+     * round it (`conFgAcc1` is `lt1` at 90% inside an `accent1` line): without the
+     * line it is a white rectangle on a white slide and reads as nothing at all.
+     *
+     * @param label The layout node's `styleLbl`.
+     * @param index The box's place in the run of siblings.
+     */
+    line(label: string | undefined, index: number): string | undefined;
+    /** The `a:solidFill` for a box's TEXT, where the part overrides the style. */
+    textFill(label: string | undefined, index: number): string | undefined;
+    private pick;
+}
+/**
+ * §21.4.2.20 `dgm:pt/dgm:spPr` — the formatting the AUTHOR set on one point,
+ * which beats whatever the colours part gives that point's style label.
+ *
+ * A cycle-matrix whose second quarter was recoloured by hand states it here and
+ * nowhere else: read only from the colours part, all four quarters came out the
+ * one accent the label names, and the orange quarter and the orange outline
+ * round its callout both vanished.
+ *
+ * @param spPr The point's `dgm:spPr`, when it has one.
+ * @returns The fill and the outline it overrides, each as DrawingML, when it
+ *          overrides them.
+ */
+export declare function pointPaint(spPr: PoNode | undefined): {
+    fill?: string;
+    line?: string;
+};