reamkit 1.15.4 → 1.17.0

package/dist/esm/core/font/ttf-subset.js

@@ -2,6 +2,31 @@
 var HEAD_CHECKSUM_ADJUSTMENT_OFFSET = 8;
 var HEAD_INDEX_TO_LOC_FORMAT_OFFSET = 50;
 var MAGIC_HEAD_CHECKSUM = 2981146554;
+/**
+* The tables a `/FontFile2` may carry (ISO 32000-1 §9.9.2).
+*
+* The spec names `glyf`, `head`, `hhea`, `hmtx`, `loca` and `maxp` as required,
+* `cvt `/`fpgm`/`prep` when the glyphs are hinted, and `cmap` for a SYMBOLIC
+* font. A CIDFontType2 with `/CIDToGIDMap /Identity` is not symbolic in that
+* sense — §9.7.4.2 makes the CID the glyph index and never consults `cmap`, so
+* 9.3 KB of it rode along in every font we embedded. Everything else is dead
+* weight too, in a PDF that does its own positioning and text extraction: we copied `post`, `GPOS`, `GSUB`, `GDEF`, `name`,
+* `hdmx`, `LTSH` and the rest through untouched, and they were 120 KB of the
+* 136 KB font program in 55906-MultiSheetRefs.xlsx. `OS/2` is kept because
+* viewers read its metrics when a descriptor is incomplete.
+*/
+var EMBEDDABLE_TABLES = new Set([
+	"glyf",
+	"head",
+	"hhea",
+	"hmtx",
+	"loca",
+	"maxp",
+	"cvt ",
+	"fpgm",
+	"prep",
+	"OS/2"
+]);
 var COMPOSITE_ARG_1_AND_2_ARE_WORDS = 1;
 var COMPOSITE_WE_HAVE_A_SCALE = 8;
 var COMPOSITE_MORE_COMPONENTS = 32;
@@ -115,7 +140,7 @@ function assembleSubsetTtf(parsed, newGlyf, newLoca) {
 	newHead[HEAD_CHECKSUM_ADJUSTMENT_OFFSET + 3] = 0;
 	newHead[HEAD_INDEX_TO_LOC_FORMAT_OFFSET] = 0;
 	newHead[HEAD_INDEX_TO_LOC_FORMAT_OFFSET + 1] = 1;
-	const orderedTags = [...parsed.tables.keys()];
+	const orderedTags = [...parsed.tables.keys()].filter((t) => EMBEDDABLE_TABLES.has(t));
 	const tableData = /* @__PURE__ */ new Map();
 	for (const tag of orderedTags) if (tag === "glyf") tableData.set(tag, newGlyf);
 	else if (tag === "loca") tableData.set(tag, newLocaBytes);

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

@@ -1,5 +1,5 @@
 /** The raster formats this module recognizes and can prepare for embedding. */
-export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000';
+export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000' | 'gif';
 /**
  * Sniff the raster format from a file's leading magic bytes (JPEG SOI, the PNG
  * signature, or a JP2 box / raw JPEG 2000 codestream). Returns the
@@ -24,7 +24,7 @@ export interface EmbedImageOptions {
  */
 export interface PreparedImage {
     readonly format: ImageFormat;
-    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png';
+    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png' | 'image/gif';
     readonly widthPx: number;
     readonly heightPx: number;
     /**

package/dist/esm/core/images.js

@@ -10,6 +10,7 @@ function detectImageFormat(bytes) {
 	if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10) return "png";
 	if (bytes.length >= 12 && bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 0 && bytes[3] === 12 && bytes[4] === 106 && bytes[5] === 80 && bytes[6] === 32 && bytes[7] === 32 && bytes[8] === 13 && bytes[9] === 10 && bytes[10] === 135 && bytes[11] === 10) return "jpeg2000";
 	if (bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 79 && bytes[2] === 255 && bytes[3] === 81) return "jpeg2000";
+	if (bytes.length >= 6 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56 && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97) return "gif";
 	return null;
 }
 /**
@@ -24,6 +25,7 @@ function prepareImage(bytes, options = {}) {
 	if (format === "jpeg") return prepareJpeg(bytes);
 	if (format === "png") return preparePng(bytes, options);
 	if (format === "jpeg2000") return prepareJpeg2000(bytes);
+	if (format === "gif") return prepareGif(bytes, options);
 	throw new Error("Unsupported image format");
 }
 function prepareJpeg2000(bytes) {
@@ -125,6 +127,185 @@ function readJpegInfo(bytes) {
 	}
 	throw new Error("JPEG SOFn marker not found");
 }
+/**
+* Decode a GIF (87a/89a) into a {@link PreparedImage}: the first frame's
+* palette indices expanded to RGB and re-compressed, with a transparent index
+* becoming a soft mask. PDF has no GIF filter, so the pixels have to be handed
+* over as raw ones — dml-picture-in-textframe.docx (and seventeen other corpus
+* documents) draw nothing at all without this.
+*
+* @param bytes   The GIF file.
+* @param options Emit options (PDF/A-1 forbids the soft mask).
+* @returns The prepared image.
+* @throws Error when the file is truncated or holds no image.
+*/
+function prepareGif(bytes, options = {}) {
+	const frame = decodeGif(bytes);
+	const rgb = new Uint8Array(frame.width * frame.height * 3);
+	const alpha = frame.transparentIndex !== void 0 ? new Uint8Array(frame.width * frame.height) : void 0;
+	for (let i = 0; i < frame.indices.length; i++) {
+		const idx = frame.indices[i];
+		const p = idx * 3;
+		rgb[i * 3] = frame.palette[p] ?? 0;
+		rgb[i * 3 + 1] = frame.palette[p + 1] ?? 0;
+		rgb[i * 3 + 2] = frame.palette[p + 2] ?? 0;
+		if (alpha) alpha[i] = idx === frame.transparentIndex ? 0 : 255;
+	}
+	if (alpha && options.flattenAlpha) {
+		for (let i = 0; i < alpha.length; i++) if (alpha[i] === 0) {
+			rgb[i * 3] = 255;
+			rgb[i * 3 + 1] = 255;
+			rgb[i * 3 + 2] = 255;
+		}
+	}
+	return {
+		format: "gif",
+		mimeType: "image/gif",
+		widthPx: frame.width,
+		heightPx: frame.height,
+		colorSpace: "DeviceRGB",
+		bitsPerComponent: 8,
+		filter: "FlateDecode",
+		data: zlibSync(rgb),
+		...alpha && !options.flattenAlpha ? { smaskData: zlibSync(alpha) } : {}
+	};
+}
+function decodeGif(bytes) {
+	const u16 = (i) => (bytes[i] ?? 0) | (bytes[i + 1] ?? 0) << 8;
+	const screenW = u16(6);
+	const screenH = u16(8);
+	const packed = bytes[10] ?? 0;
+	let pos = 13;
+	let globalPalette = new Uint8Array(0);
+	if ((packed & 128) !== 0) {
+		const size = 3 * (1 << (packed & 7) + 1);
+		globalPalette = bytes.subarray(pos, pos + size);
+		pos += size;
+	}
+	let transparentIndex;
+	while (pos < bytes.length) {
+		const block = bytes[pos];
+		if (block === 33) {
+			const label = bytes[pos + 1];
+			pos += 2;
+			if (label === 249 && (bytes[pos + 1] & 1) !== 0) transparentIndex = bytes[pos + 4];
+			while (pos < bytes.length && bytes[pos] !== 0) pos += bytes[pos] + 1;
+			pos++;
+			continue;
+		}
+		if (block !== 44) break;
+		const width = u16(pos + 5) || screenW;
+		const height = u16(pos + 7) || screenH;
+		const flags = bytes[pos + 9];
+		pos += 10;
+		let palette = globalPalette;
+		if ((flags & 128) !== 0) {
+			const size = 3 * (1 << (flags & 7) + 1);
+			palette = bytes.subarray(pos, pos + size);
+			pos += size;
+		}
+		const minCodeSize = bytes[pos];
+		pos++;
+		const chunks = [];
+		while (pos < bytes.length && bytes[pos] !== 0) {
+			const len = bytes[pos];
+			chunks.push(bytes.subarray(pos + 1, pos + 1 + len));
+			pos += len + 1;
+		}
+		const indices = lzwDecode(concatBytes(chunks), minCodeSize, width * height);
+		return {
+			width,
+			height,
+			indices: (flags & 64) !== 0 ? deinterlace(indices, width, height) : indices,
+			palette,
+			...transparentIndex !== void 0 ? { transparentIndex } : {}
+		};
+	}
+	throw new Error("GIF holds no image");
+}
+function lzwDecode(data, minCodeSize, pixelCount) {
+	const clear = 1 << minCodeSize;
+	const end = clear + 1;
+	const out = new Uint8Array(pixelCount);
+	let outPos = 0;
+	let prefix = new Int32Array(4096);
+	let suffix = new Uint8Array(4096);
+	let length = new Int32Array(4096);
+	const reset = () => {
+		prefix = new Int32Array(4096);
+		suffix = new Uint8Array(4096);
+		length = new Int32Array(4096);
+		for (let i = 0; i < clear; i++) {
+			prefix[i] = -1;
+			suffix[i] = i;
+			length[i] = 1;
+		}
+	};
+	reset();
+	let next = end + 1;
+	let codeSize = minCodeSize + 1;
+	let prev = -1;
+	let bitBuf = 0;
+	let bitCount = 0;
+	const stack = new Uint8Array(4096);
+	for (let i = 0; i < data.length || bitCount >= codeSize;) {
+		while (bitCount < codeSize && i < data.length) {
+			bitBuf |= (data[i] & 255) << bitCount;
+			bitCount += 8;
+			i++;
+		}
+		if (bitCount < codeSize) break;
+		const code = bitBuf & (1 << codeSize) - 1;
+		bitBuf >>>= codeSize;
+		bitCount -= codeSize;
+		if (code === clear) {
+			reset();
+			next = end + 1;
+			codeSize = minCodeSize + 1;
+			prev = -1;
+			continue;
+		}
+		if (code === end) break;
+		let cur = code;
+		if (code >= next) {
+			if (prev < 0) break;
+			cur = prev;
+		}
+		let depth = 0;
+		while (cur >= 0 && depth < 4096) {
+			stack[depth] = suffix[cur];
+			depth++;
+			cur = prefix[cur];
+		}
+		if (code >= next) stack[depth++] = stack[depth - 2] ?? 0;
+		for (let d = depth - 1; d >= 0 && outPos < out.length; d--) out[outPos++] = stack[d];
+		if (prev >= 0 && next < 4096) {
+			prefix[next] = prev;
+			suffix[next] = stack[depth - 1];
+			length[next] = (length[prev] ?? 1) + 1;
+			next++;
+			if (next === 1 << codeSize && codeSize < 12) codeSize++;
+		}
+		prev = code < next ? code : prev;
+		if (outPos >= out.length) break;
+	}
+	return out;
+}
+function deinterlace(src, width, height) {
+	const out = new Uint8Array(src.length);
+	const passes = [
+		[0, 8],
+		[4, 8],
+		[2, 4],
+		[1, 2]
+	];
+	let row = 0;
+	for (const [start, step] of passes) for (let y = start; y < height; y += step) {
+		out.set(src.subarray(row * width, (row + 1) * width), y * width);
+		row++;
+	}
+	return out;
+}
 function preparePng(bytes, options = {}) {
 	let decoded = decodePng(bytes);
 	if (options.flattenAlpha && decoded.smaskRaw) decoded = flattenAlphaOnWhite(decoded);
@@ -146,6 +327,8 @@ function decodePng(bytes) {
 	let bitDepth = 0;
 	let colorType = 0;
 	let interlaceMethod = 0;
+	let palette;
+	let paletteAlpha;
 	const idatChunks = [];
 	let pos = 8;
 	while (pos + 12 <= bytes.length) {
@@ -158,57 +341,161 @@ function decodePng(bytes) {
 			bitDepth = bytes[dataOff + 8];
 			colorType = bytes[dataOff + 9];
 			interlaceMethod = bytes[dataOff + 12];
-		} else if (type === "IDAT") idatChunks.push(bytes.subarray(dataOff, dataOff + len));
+		} else if (type === "PLTE") palette = bytes.subarray(dataOff, dataOff + len);
+		else if (type === "tRNS") paletteAlpha = bytes.subarray(dataOff, dataOff + len);
+		else if (type === "IDAT") idatChunks.push(bytes.subarray(dataOff, dataOff + len));
 		else if (type === "IEND") break;
 		pos = dataOff + len + 4;
 	}
 	if (width === 0 || height === 0) throw new Error("PNG: missing IHDR");
 	if (idatChunks.length === 0) throw new Error("PNG: no IDAT");
-	if (interlaceMethod !== 0) throw new Error("PNG: interlaced not supported");
-	if (bitDepth !== 8) throw new Error(`PNG: bit depth ${bitDepth} not supported`);
-	const inflated = unzlibSync(concatBytes(idatChunks));
+	if (![
+		1,
+		2,
+		4,
+		8,
+		16
+	].includes(bitDepth)) throw new Error(`PNG: bit depth ${bitDepth} not supported`);
 	const channels = pngChannels(colorType);
 	if (channels === 0) throw new Error(`PNG color type ${colorType} not supported`);
-	const bpp = channels;
-	const scanlineBytes = width * bpp;
-	const expected = height * (1 + scanlineBytes);
-	if (inflated.length !== expected) throw new Error(`PNG: inflated size ${inflated.length} != expected ${expected} (interlaced or malformed)`);
-	const raw = new Uint8Array(height * scanlineBytes);
-	let prev = null;
-	for (let y = 0; y < height; y++) {
-		const inOff = y * (1 + scanlineBytes);
-		const filterType = inflated[inOff];
-		const decoded = new Uint8Array(scanlineBytes);
-		for (let x = 0; x < scanlineBytes; x++) {
-			const filt = inflated[inOff + 1 + x];
-			const a = x < bpp ? 0 : decoded[x - bpp];
-			const b = prev ? prev[x] : 0;
-			const c = !prev || x < bpp ? 0 : prev[x - bpp];
-			let v;
-			switch (filterType) {
-				case 0:
-					v = filt;
-					break;
-				case 1:
-					v = filt + a;
-					break;
-				case 2:
-					v = filt + b;
-					break;
-				case 3:
-					v = filt + Math.floor((a + b) / 2);
-					break;
-				case 4:
-					v = filt + paethPredictor(a, b, c);
-					break;
-				default: throw new Error(`PNG: unknown filter type ${filterType}`);
+	const raw = decodeSamples(unzlibSync(concatBytes(idatChunks)), width, height, channels, bitDepth, interlaceMethod === 1, colorType !== 3);
+	return splitChannels(width, height, colorType, raw, palette, paletteAlpha);
+}
+/**
+* §7.2 / §9 — the image's samples, one byte each, in `width × height ×
+* channels` order: the IDAT stream inflated, each scanline unfiltered against
+* the one before it, and (when the image is interlaced) each of Adam7's seven
+* passes scattered back into the full-size grid.
+*
+* @param inflated    The inflated IDAT stream.
+* @param width       Image width in pixels.
+* @param height      Image height in pixels.
+* @param channels    Samples per pixel for the colour type.
+* @param bitDepth    Bits per sample (1, 2, 4, 8 or 16).
+* @param interlaced  True for interlace method 1 (Adam7).
+* @param scaleToByte Stretch a sub-byte sample to 0…255 — right for an
+*                    intensity, wrong for a palette index.
+* @returns One byte per sample.
+*/
+function decodeSamples(inflated, width, height, channels, bitDepth, interlaced, scaleToByte) {
+	const out = new Uint8Array(width * height * channels);
+	const passes = interlaced ? ADAM7_PASSES : [{
+		xStart: 0,
+		yStart: 0,
+		xStep: 1,
+		yStep: 1
+	}];
+	const maxSample = (1 << Math.min(bitDepth, 8)) - 1;
+	const bpp = Math.max(1, Math.ceil(channels * bitDepth / 8));
+	let off = 0;
+	for (const p of passes) {
+		const pw = Math.ceil((width - p.xStart) / p.xStep);
+		const ph = Math.ceil((height - p.yStart) / p.yStep);
+		if (pw <= 0 || ph <= 0) continue;
+		const lineBytes = Math.ceil(pw * channels * bitDepth / 8);
+		let prev = null;
+		for (let y = 0; y < ph; y++) {
+			if (off + 1 + lineBytes > inflated.length) throw new Error("PNG: truncated image data");
+			const filterType = inflated[off];
+			const line = unfilterScanline(inflated, off + 1, lineBytes, bpp, filterType, prev);
+			off += 1 + lineBytes;
+			const destY = p.yStart + y * p.yStep;
+			for (let px = 0; px < pw; px++) {
+				const destX = p.xStart + px * p.xStep;
+				const dest = (destY * width + destX) * channels;
+				for (let ch = 0; ch < channels; ch++) {
+					const v = sampleAt(line, px * channels + ch, bitDepth);
+					out[dest + ch] = scaleToByte && bitDepth < 8 ? Math.round(v * 255 / maxSample) : v;
+				}
 			}
-			decoded[x] = v & 255;
+			prev = line;
+		}
+	}
+	return out;
+}
+/**
+* §9.2 — Adam7's seven passes, each a sub-grid of the image: where the pass
+* starts and how far apart its pixels sit.
+*/
+var ADAM7_PASSES = [
+	{
+		xStart: 0,
+		yStart: 0,
+		xStep: 8,
+		yStep: 8
+	},
+	{
+		xStart: 4,
+		yStart: 0,
+		xStep: 8,
+		yStep: 8
+	},
+	{
+		xStart: 0,
+		yStart: 4,
+		xStep: 4,
+		yStep: 8
+	},
+	{
+		xStart: 2,
+		yStart: 0,
+		xStep: 4,
+		yStep: 4
+	},
+	{
+		xStart: 0,
+		yStart: 2,
+		xStep: 2,
+		yStep: 4
+	},
+	{
+		xStart: 1,
+		yStart: 0,
+		xStep: 2,
+		yStep: 2
+	},
+	{
+		xStart: 0,
+		yStart: 1,
+		xStep: 1,
+		yStep: 2
+	}
+];
+function unfilterScanline(src, from, lineBytes, bpp, filterType, prev) {
+	const decoded = new Uint8Array(lineBytes);
+	for (let x = 0; x < lineBytes; x++) {
+		const filt = src[from + x];
+		const a = x < bpp ? 0 : decoded[x - bpp];
+		const b = prev ? prev[x] : 0;
+		const c = !prev || x < bpp ? 0 : prev[x - bpp];
+		let v;
+		switch (filterType) {
+			case 0:
+				v = filt;
+				break;
+			case 1:
+				v = filt + a;
+				break;
+			case 2:
+				v = filt + b;
+				break;
+			case 3:
+				v = filt + Math.floor((a + b) / 2);
+				break;
+			case 4:
+				v = filt + paethPredictor(a, b, c);
+				break;
+			default: throw new Error(`PNG: unknown filter type ${filterType}`);
 		}
-		raw.set(decoded, y * scanlineBytes);
-		prev = decoded;
+		decoded[x] = v & 255;
 	}
-	return splitChannels(width, height, colorType, raw);
+	return decoded;
+}
+function sampleAt(line, i, bitDepth) {
+	if (bitDepth === 8) return line[i];
+	if (bitDepth === 16) return line[i * 2];
+	const per = 8 / bitDepth;
+	return (line[Math.floor(i / per)] ?? 0) >> 8 - bitDepth * (i % per + 1) & (1 << bitDepth) - 1;
 }
 function flattenAlphaOnWhite(decoded) {
 	const alpha = decoded.smaskRaw;
@@ -231,7 +518,7 @@ function flattenAlphaOnWhite(decoded) {
 		bitsPerComponent: decoded.bitsPerComponent
 	};
 }
-function splitChannels(width, height, colorType, raw) {
+function splitChannels(width, height, colorType, raw, palette, paletteAlpha) {
 	const pixelCount = width * height;
 	if (colorType === 0) return {
 		width,
@@ -240,6 +527,28 @@ function splitChannels(width, height, colorType, raw) {
 		colorSpace: "DeviceGray",
 		bitsPerComponent: 8
 	};
+	if (colorType === 3) {
+		if (!palette || palette.length < 3) throw new Error("PNG: palette image without PLTE");
+		const entries = Math.floor(palette.length / 3);
+		const rgb = new Uint8Array(pixelCount * 3);
+		const alpha = paletteAlpha && paletteAlpha.length > 0 ? new Uint8Array(pixelCount) : void 0;
+		for (let i = 0; i < pixelCount; i++) {
+			const idx = raw[i];
+			const src = (idx < entries ? idx : 0) * 3;
+			rgb[i * 3] = palette[src];
+			rgb[i * 3 + 1] = palette[src + 1];
+			rgb[i * 3 + 2] = palette[src + 2];
+			if (alpha) alpha[i] = paletteAlpha[idx] ?? 255;
+		}
+		return {
+			width,
+			height,
+			raw: rgb,
+			colorSpace: "DeviceRGB",
+			bitsPerComponent: 8,
+			...alpha ? { smaskRaw: alpha } : {}
+		};
+	}
 	if (colorType === 2) return {
 		width,
 		height,
@@ -281,11 +590,12 @@ function splitChannels(width, height, colorType, raw) {
 			smaskRaw: alpha
 		};
 	}
-	throw new Error(`PNG color type ${colorType} not supported (palette/indexed?)`);
+	throw new Error(`PNG color type ${colorType} not supported`);
 }
 function pngChannels(colorType) {
 	if (colorType === 0) return 1;
 	if (colorType === 2) return 3;
+	if (colorType === 3) return 1;
 	if (colorType === 4) return 2;
 	if (colorType === 6) return 4;
 	return 0;

package/dist/esm/core/indexed-colors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ECMA-376 §18.8.27 — the legacy indexed colour palette a `<color indexed="N">`
+ * refers to. It predates `rgb` and theme colours and is still what Excel writes
+ * for anything picked from the classic 40-colour dropdown, so a file using it
+ * is not unusual: tdf58243.xlsx colours its header cells `indexed="10"`, and
+ * ignoring the attribute rendered them black where every other reader shows red.
+ *
+ * Entries 0-7 are repeated at 8-15 (a quirk of the original palette); 64 and 65
+ * are the system foreground and background.
+ */
+export declare const INDEXED_COLORS: ReadonlyArray<string>;

package/dist/esm/core/indexed-colors.js

@@ -0,0 +1,81 @@
+//#region src/core/indexed-colors.ts
+/**
+* ECMA-376 §18.8.27 — the legacy indexed colour palette a `<color indexed="N">`
+* refers to. It predates `rgb` and theme colours and is still what Excel writes
+* for anything picked from the classic 40-colour dropdown, so a file using it
+* is not unusual: tdf58243.xlsx colours its header cells `indexed="10"`, and
+* ignoring the attribute rendered them black where every other reader shows red.
+*
+* Entries 0-7 are repeated at 8-15 (a quirk of the original palette); 64 and 65
+* are the system foreground and background.
+*/
+var INDEXED_COLORS = [
+	"000000",
+	"FFFFFF",
+	"FF0000",
+	"00FF00",
+	"0000FF",
+	"FFFF00",
+	"FF00FF",
+	"00FFFF",
+	"000000",
+	"FFFFFF",
+	"FF0000",
+	"00FF00",
+	"0000FF",
+	"FFFF00",
+	"FF00FF",
+	"00FFFF",
+	"800000",
+	"008000",
+	"000080",
+	"808000",
+	"800080",
+	"008080",
+	"C0C0C0",
+	"808080",
+	"9999FF",
+	"993366",
+	"FFFFCC",
+	"CCFFFF",
+	"660066",
+	"FF8080",
+	"0066CC",
+	"CCCCFF",
+	"000080",
+	"FF00FF",
+	"FFFF00",
+	"00FFFF",
+	"800080",
+	"800000",
+	"008080",
+	"0000FF",
+	"00CCFF",
+	"CCFFFF",
+	"CCFFCC",
+	"FFFF99",
+	"99CCFF",
+	"FF99CC",
+	"CC99FF",
+	"FFCC99",
+	"3366FF",
+	"33CCCC",
+	"99CC00",
+	"FFCC00",
+	"FF9900",
+	"FF6600",
+	"666699",
+	"969696",
+	"003366",
+	"339966",
+	"003300",
+	"333300",
+	"993300",
+	"993366",
+	"333399",
+	"333333",
+	"000000",
+	"FFFFFF"
+];
+//#endregion
+export { INDEXED_COLORS };

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

@@ -1,4 +1,4 @@
-import { BodyElement, Chart, Comment, DocumentInfo, Numbering, Section, SectionProperties, StyleSheet } from '../document-model/index.js';
+import { BodyElement, Chart, Comment, DocumentInfo, Numbering, Section, SectionProperties, ShapeFill, StyleSheet } from '../document-model/index.js';
 import { FontRegistry } from '../font/index.js';
 import { ResourceStore } from './resources.js';
 /**
@@ -46,4 +46,26 @@ export interface FlowDoc {
     readonly info?: DocumentInfo;
     /** Document natural language hint (BCP-47), e.g. for tagged-PDF /Lang. */
     readonly language?: string;
+    /**
+     * ECMA-376 §17.15.1.35 `w:doNotExpandShiftReturn` — a justified line that
+     * ends at a soft line break keeps its natural width.
+     */
+    readonly doNotExpandShiftReturn?: boolean;
+    /**
+     * ECMA-376 §17.2.1 `w:background` — the colour every page is painted, when
+     * the document asks for one AND §17.15.1.28 `w:displayBackgroundShape` says
+     * to draw it.
+     */
+    readonly pageBackgroundColorHex?: string;
+    /**
+     * ECMA-376 §17.2.1 — the same background as the FILL it is, when that is more
+     * than a flat colour: the `v:background`'s gradient or picture. The colour
+     * above stays the flat fallback, for writers that paint only colours.
+     */
+    readonly pageBackgroundFill?: ShapeFill;
+    /**
+     * ECMA-376 §17.15.1.38 `w:gutterAtTop` — the binding space `w:pgMar
+     * @w:gutter` reserves belongs to the TOP margin rather than the left.
+     */
+    readonly gutterAtTop?: boolean;
 }