reamkit 1.15.4 → 1.16.0

package/dist/esm/core/drawingml/theme-parser.js

@@ -3,6 +3,7 @@ import { XMLParser } from "fast-xml-parser";
 //#region src/core/drawingml/theme-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	preserveOrder: true,
@@ -53,6 +54,78 @@ function parseTheme(themeXml) {
 	}
 	return out;
 }
+/**
+* Parse a theme's line-style widths (ECMA-376 §20.1.4.1.21 `a:lnStyleLst`).
+*
+* A shape drawn from the gallery keeps its outline as `<a:lnRef idx="N">`,
+* which is a 1-based index into this list — the reference names the colour and
+* the list holds the width. The standard Office theme is 0.75pt / 2pt / 3pt.
+*
+* @param themeXml The raw theme part bytes, UTF-8.
+* @returns The widths in points, in list order; empty when the theme declares
+*          no `a:fmtScheme`.
+*/
+function parseThemeLineWidths(themeXml) {
+	const list = poFindByPath(parser.parse(decoder.decode(themeXml)), [
+		"a:theme",
+		"a:themeElements",
+		"a:fmtScheme",
+		"a:lnStyleLst"
+	]);
+	if (!list) return [];
+	const out = [];
+	for (const ln of poChildren(list)) {
+		if (!poIs(ln, "a:ln")) continue;
+		const w = Number(poAttr(ln, "w") ?? "");
+		out.push(Number.isFinite(w) && w > 0 ? w / EMU_PER_POINT : .75);
+	}
+	return out;
+}
+/**
+* Parse a theme's fill styles (§20.1.4.1.13 `a:fillStyleLst`), as the raw nodes.
+*
+* A shape drawn from the gallery carries no fill of its own — only
+* `<a:fillRef idx="N">`, a 1-based index into this list, and a colour to put
+* where the styles say `phClr`. The standard Office theme's slots are a solid,
+* a subtle gradient and a stronger one, so reading the reference's colour alone
+* paints slot 3 flat: 47504.xlsx's rectangle is a gradient in both references
+* and a single blue in ours.
+*
+* The nodes are handed back unparsed because what they hold is a whole fill —
+* solid, gradient, pattern — which the shape readers already know how to read.
+*
+* @param themeXml The raw theme part bytes, UTF-8.
+* @returns The `a:fillStyleLst` children in list order; empty when the theme
+*          declares no `a:fmtScheme`.
+*/
+function parseThemeFillStyles(themeXml) {
+	const list = poFindByPath(parser.parse(decoder.decode(themeXml)), [
+		"a:theme",
+		"a:themeElements",
+		"a:fmtScheme",
+		"a:fillStyleLst"
+	]);
+	return list ? [...poChildren(list)] : [];
+}
+/**
+* Parse a theme's effect styles (§20.1.4.1.15 `a:effectStyleLst`), as the raw
+* nodes. `<a:effectRef idx="N">` is a 1-based index into this list, exactly as
+* the fill and line references index theirs.
+*
+* @param themeXml The raw theme part bytes, UTF-8.
+* @returns The `a:effectStyle` children in list order; empty when the theme
+*          declares no `a:fmtScheme`.
+*/
+function parseThemeEffectStyles(themeXml) {
+	const list = poFindByPath(parser.parse(decoder.decode(themeXml)), [
+		"a:theme",
+		"a:themeElements",
+		"a:fmtScheme",
+		"a:effectStyleLst"
+	]);
+	return list ? [...poChildren(list)] : [];
+}
+var EMU_PER_POINT = 12700;
 function colorOf(slot) {
 	for (const c of poChildren(slot)) if (poIs(c, "a:srgbClr")) {
 		const v = poAttr(c, "val");
@@ -63,4 +136,4 @@ function colorOf(slot) {
 	}
 }
 //#endregion
-export { parseTheme };
+export { parseTheme, parseThemeEffectStyles, parseThemeFillStyles, parseThemeLineWidths };

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.js

@@ -146,6 +146,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 +160,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 +337,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 +346,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 +409,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/sheet.d.ts

@@ -10,6 +10,9 @@ export interface SheetChartRef {
     readonly chartPartPath: string;
     readonly widthPt: number;
     readonly heightPt: number;
+    /** Where the anchor puts it, in points from the grid's top-left. */
+    readonly xPt?: number;
+    readonly yPt?: number;
 }
 /**
  * §20.5.2.1 xdr:pic — a picture anchored over a sheet's grid, sized from its
@@ -20,6 +23,9 @@ export interface SheetImageRef {
     readonly resourceId: ResourceId;
     readonly widthPt: number;
     readonly heightPt: number;
+    /** Where the anchor puts it, in points from the grid's top-left. */
+    readonly xPt?: number;
+    readonly yPt?: number;
 }
 /** One item (label + selection state) in a {@link SheetSlicer}. */
 export interface SheetSlicerItem {
@@ -73,10 +79,38 @@ export interface SheetComment {
  * spin/scroll/list controls. Render-only.
  */
 export interface SheetFormControl {
+    /**
+     * §18.3.1.19 `<control name>` — the shape's NAME, an identifier like
+     * "CheckBox28". Excel shows it in the name box, never on the page; it is what
+     * the after-the-grid listing calls a control that has no geometry.
+     */
     readonly name?: string;
+    /**
+     * The visible label, from the control's legacy VML `<v:textbox>`. A control
+     * drawn in place draws THIS beside its widget — never {@link name}, which is
+     * an internal id: 45540_form_Header.xlsx has forty captionless check boxes
+     * and printing their names put "CheckBox28" across the form's own text.
+     */
+    readonly caption?: string;
     readonly objectType?: string;
     readonly checked?: boolean;
     readonly value?: number;
+    /** Where the control sits on the sheet, in points from the grid's origin. */
+    readonly box?: SheetControlBox;
+    /** The caption's declared size, when the shape names one. */
+    readonly fontSizePt?: number;
+}
+/**
+ * A control's rectangle on the sheet, in points from the grid's top-left — read
+ * from its legacy VML shape, the only part that says where a control goes.
+ * Absent when the drawing carries no geometry, in which case the control is
+ * listed after the grid rather than drawn in place.
+ */
+export interface SheetControlBox {
+    readonly xPt: number;
+    readonly yPt: number;
+    readonly widthPt: number;
+    readonly heightPt: number;
 }
 /**
  * An ActiveX control resolved against its activeX part (E-SHEET W10): the control
@@ -87,6 +121,8 @@ export interface SheetFormControl {
  */
 export interface SheetActiveXControl {
     readonly type: string;
+    /** Where the control sits on the sheet — from the VML shape sharing its `shapeId`. */
+    readonly box?: SheetControlBox;
     /** §18.3.1.19 `<control name>` — the control's identifier, when it came that way. */
     readonly name?: string;
     readonly caption?: string;
@@ -97,6 +133,12 @@ export interface SheetActiveXControl {
 export interface Sheet {
     /** The sheet (tab) name. */
     readonly name: string;
+    /**
+     * §18.2.19 `<sheet @state>` — the tab is `hidden` or `veryHidden`. Carried
+     * because a consumer that shows the workbook (the HTML writer) may still want
+     * it; the paginated projection skips it, as Excel and LibreOffice do.
+     */
+    readonly hidden?: boolean;
     /**
      * The grid + per-sheet geometry exactly as parsed: cells, columns, rows,
      * merges, dimensions, pageSetup/printOptions, manual breaks, drawingRelId.
@@ -165,4 +207,23 @@ export interface SheetDoc {
     readonly resources: ResourceStore;
     /** Document metadata from docProps/core.xml. */
     readonly info?: DocumentInfo;
+    /**
+     * §20.1.6.2 the workbook theme's colour scheme, slot name → 6-hex. Cell
+     * colours are resolved against it at parse time; a header/footer's `&K` theme
+     * reference is resolved at projection time, which is why the palette travels.
+     */
+    readonly themePalette?: ReadonlyMap<string, string>;
+    /**
+     * §18.3.* — how many embedded objects (`<oleObject progId="Package">` and the
+     * like) the workbook carries. They print as an icon and a caption in Excel
+     * and Calc, both of which live in a metafile; the projection reports them.
+     */
+    readonly embeddedObjects?: number;
+    /**
+     * §20.5.2.x — how many anchored pictures are a metafile (WMF / EMF / PICT)
+     * rather than a raster. They keep their anchor and their box, and draw
+     * nothing: replaying a metafile is a different feature from embedding an
+     * image. The projection reports them.
+     */
+    readonly metafilePictures?: number;
 }

package/dist/esm/{excel → core}/number-format.d.ts

@@ -13,6 +13,20 @@
  * @returns The formatted display string.
  */
 export declare function applyNumberFormat(rawValue: string, numFmtId: number, customFormats: ReadonlyMap<number, string>, date1904?: boolean): string;
+/**
+ * The colour a number format paints its cell in (§18.8.31), as a 6-digit RRGGBB,
+ * or undefined when the section that applies declares none.
+ *
+ * A `[Red]` at the head of a section is part of the format, not decoration: the
+ * accounting codes write the negative section as `[Red]-#,##0.00`, and rendering
+ * it in the cell's own font colour loses the one signal the format exists for.
+ * `[Color 12]` indexes the same legacy palette a `<color indexed>` does.
+ *
+ * @param rawValue      The cell's raw stored value — it selects the section.
+ * @param numFmtId      The number-format id from the cell's `cellXf`.
+ * @param customFormats Custom format codes by id (from `<numFmts>`).
+ */
+export declare function numberFormatColorHex(rawValue: string, numFmtId: number, customFormats: ReadonlyMap<number, string>): string | undefined;
 /**
  * Excel serial date → JS `Date`. The default 1900 epoch uses 1899-12-30 as day 0
  * (so serial 1 is 1900-01-01) and inherits the Lotus 1-2-3 leap-year bug: serial 60
@@ -35,3 +49,26 @@ export declare function excelSerialToDate(serial: number, date1904: boolean): Da
  * @param month0 The 0-indexed month (0 = January).
  */
 export declare function excelSerialFromUtcParts(year: number, month0: number, day: number, date1904: boolean): number;
+/**
+ * A General number rounded to the decimals that fit `maxChars` characters.
+ *
+ * General is not a fixed format: a spreadsheet shows as many decimal places as
+ * the column has room for and ROUNDS to that, so 4.3900875881221957 in a
+ * column eight characters wide reads 4.390088. We rendered every stored digit
+ * and let the cell clip it, which turns the same value into 4.390087 — off by
+ * one in the last place shown, with nothing to say a digit was cut.
+ *
+ * The integer part is never dropped: a number too wide even without decimals
+ * keeps them all and the cell says so its own way (see hashOnOverflow).
+ *
+ * `fits` decides, and it must measure in the face this will be DRAWN in rather
+ * than count characters against the column's width in the document's unit.
+ * Counted that way we produced nine digits for a column that holds nine of
+ * Excel's and eight of ours, and the layout clipped the ninth — the very
+ * truncation this exists to prevent. Fewer digits than the reference shows is a
+ * coarser number; a clipped one is a different number.
+ *
+ * @param rawValue The cell's stored value.
+ * @param fits     Whether a rendering will fit the cell.
+ */
+export declare function generalToWidth(rawValue: string, fits: (text: string) => boolean): string;