reamkit 1.22.0 → 1.24.0

package/dist/esm/core/metafile/wmf.js

@@ -1,5 +1,7 @@
 import { PathBuilder } from "../vector.js";
-import { cloneDc, colorRef, newDeviceContext } from "./picture.js";
+import { clippedAway, cloneDc, colorRef, intersectClip, newDeviceContext, primBounds } from "./picture.js";
+import { cropDib, readDib } from "./dib.js";
+import { makeBlitter } from "./blit.js";
 import { fromSymbolFont, symbolGeometryOf, symbolOutline } from "./symbol-fonts.js";
 import { ellipseSegments } from "./emf.js";
 //#region src/core/metafile/wmf.ts
@@ -14,9 +16,6 @@ function isWmf(bytes) {
 	return (type === 1 || type === 2) && headerWords === 9;
 }
 var RECORD_NAMES = new Map([
-	[2368, "bitmap"],
-	[2881, "bitmap"],
-	[3907, "bitmap"],
 	[2338, "pie"],
 	[2096, "chord"],
 	[2071, "arc"],
@@ -61,6 +60,17 @@ function readWmf(bytes) {
 		cx: 0,
 		cy: 0
 	};
+	let origin;
+	const emit = (prim) => {
+		if (clippedAway(dc, primBounds(prim))) return;
+		origin ??= {
+			x: win.x,
+			y: win.y
+		};
+		const dx = origin.x - win.x;
+		const dy = origin.y - win.y;
+		prims.push(dx === 0 && dy === 0 ? prim : shiftPrim(prim, dx, dy));
+	};
 	const strokeOf = () => {
 		if (dc.pen.style === "none") return void 0;
 		const w = Math.max(1, dc.pen.widthLu);
@@ -79,7 +89,7 @@ function readWmf(bytes) {
 		const st = stroke ? strokeOf() : void 0;
 		const fillHex = fill && !dc.brush.hollow ? dc.brush.colorHex : void 0;
 		if (fillHex === void 0 && !st) return;
-		prims.push({
+		emit({
 			kind: "path",
 			paths: [path],
 			...fillHex !== void 0 ? { fillColorHex: fillHex } : {},
@@ -87,6 +97,27 @@ function readWmf(bytes) {
 		});
 	};
 	const rectSegments = (l, t, r, b) => new PathBuilder().moveTo(l, t).lineTo(r, t).lineTo(r, b).lineTo(l, b).close().build().segments;
+	const blitter = makeBlitter(emit);
+	/**
+	* §2.3.1 — one blit record: the packed bitmap the record ends with, into the
+	* destination rectangle its fields name. A WMF's coordinates are its own
+	* logical units, which is the frame the primitives are already in.
+	*/
+	const blit = (o) => {
+		const dib = readDib(bytes, off + o.dibAt);
+		if (!dib) {
+			skipped.add("bitmap");
+			return;
+		}
+		const s = o.src;
+		const part = s.x !== 0 || s.y !== 0 || s.w !== dib.width || s.h !== dib.height ? cropDib(dib, s.x, dib.bottomUp === true ? dib.height - s.y - s.h : s.y, s.w, s.h) : dib;
+		blitter.blit(part, {
+			x: Math.min(o.dest.x, o.dest.x + o.dest.w),
+			y: Math.min(o.dest.y, o.dest.y + o.dest.h),
+			width: Math.abs(o.dest.w),
+			height: Math.abs(o.dest.h)
+		}, o.rop);
+	};
 	let off = placeable ? 22 : 0;
 	off += 18;
 	let guard = 0;
@@ -115,6 +146,17 @@ function readWmf(bytes) {
 					cy: p(0)
 				};
 				break;
+			case 1046:
+				dc = {
+					...dc,
+					clip: intersectClip(dc, {
+						bottom: p(0),
+						right: p(1),
+						top: p(2),
+						left: p(3)
+					})
+				};
+				break;
 			case 30:
 				stack.push(cloneDc(dc));
 				break;
@@ -135,6 +177,12 @@ function readWmf(bytes) {
 			case 496:
 				objects[pu(0)] = void 0;
 				break;
+			case 247:
+			case 322:
+			case 505:
+			case 1791:
+				put({ kind: "other" });
+				break;
 			case 762:
 				put({
 					kind: "pen",
@@ -223,6 +271,79 @@ function readWmf(bytes) {
 					dc.brush = brush;
 				}
 				break;
+			case 2368:
+			case 2881:
+			case 3907:
+				{
+					const rop = p32(0);
+					const f = fn === 2368 ? {
+						dib: 22,
+						srcH: 4,
+						srcW: 5,
+						ySrc: 2,
+						xSrc: 3,
+						h: 4,
+						w: 5,
+						y: 6,
+						x: 7
+					} : fn === 2881 ? {
+						dib: 26,
+						srcH: 2,
+						srcW: 3,
+						ySrc: 4,
+						xSrc: 5,
+						h: 6,
+						w: 7,
+						y: 8,
+						x: 9
+					} : {
+						dib: 28,
+						srcH: 3,
+						srcW: 4,
+						ySrc: 5,
+						xSrc: 6,
+						h: 7,
+						w: 8,
+						y: 9,
+						x: 10
+					};
+					if (f.dib + 12 > size * 2) {
+						const hex = rop === 66 ? "000000" : rop === 16711778 ? "FFFFFF" : void 0;
+						const brush = dc.brush;
+						if (hex !== void 0) dc.brush = {
+							kind: "brush",
+							colorHex: hex,
+							hollow: false
+						};
+						const shift = fn === 2368 ? 1 : 0;
+						const [h, w, y, x] = [
+							p(f.h + shift),
+							p(f.w + shift),
+							p(f.y + shift),
+							p(f.x + shift)
+						];
+						paint(rectSegments(x, y, x + w, y + h), true, false);
+						dc.brush = brush;
+						break;
+					}
+					blit({
+						dibAt: f.dib,
+						dest: {
+							x: p(f.x),
+							y: p(f.y),
+							w: p(f.w),
+							h: p(f.h)
+						},
+						src: {
+							x: p(f.xSrc),
+							y: p(f.ySrc),
+							w: p(f.srcW),
+							h: p(f.srcH)
+						},
+						rop
+					});
+				}
+				break;
 			case 804:
 			case 805:
 				{
@@ -251,7 +372,7 @@ function readWmf(bytes) {
 					const count = pu(0);
 					const text = readString(bytes, off + 8, count, false);
 					const words = count + 1 >> 1;
-					pushText(prims, dc, text, p(1 + words + 1), p(1 + words));
+					pushText(emit, dc, text, p(1 + words + 1), p(1 + words));
 				}
 				break;
 			case 2610:
@@ -261,7 +382,7 @@ function readWmf(bytes) {
 					const count = pu(2);
 					const hasRect = (pu(3) & 6) !== 0;
 					const text = readString(bytes, off + 6 + (4 + (hasRect ? 4 : 0)) * 2, count, false);
-					pushText(prims, dc, text, x, y);
+					pushText(emit, dc, text, x, y);
 				}
 				break;
 			default:
@@ -279,24 +400,25 @@ function readWmf(bytes) {
 		right: win.x + (win.cx || 1e3),
 		bottom: win.y + (win.cy || 1e3)
 	};
+	const flipped = win.cy < 0 ? prims.map((p) => mirrorPrimY(p, box.top + box.bottom)) : prims;
 	return {
-		left: box.left,
-		top: box.top,
+		left: Math.min(box.left, box.right),
+		top: Math.min(box.top, box.bottom),
 		width: Math.max(1, Math.abs(box.right - box.left)),
 		height: Math.max(1, Math.abs(box.bottom - box.top)),
-		prims,
+		prims: flipped,
 		skipped: [...skipped]
 	};
 }
-function pushText(prims, dc, text, x, y) {
+function pushText(emit, dc, text, x, y) {
 	if (text.trim() === "") return;
 	const em = Math.abs(dc.font?.heightLu ?? 12);
 	const drawn = symbolPrims(text, dc, x, y, em);
 	if (drawn) {
-		prims.push(...drawn);
+		for (const prim of drawn) emit(prim);
 		return;
 	}
-	prims.push({
+	emit({
 		kind: "text",
 		text: fromSymbolFont(text, dc.font?.family),
 		x,
@@ -311,6 +433,73 @@ function pushText(prims, dc, text, x, y) {
 		...dc.font?.escapement ? { escapement: dc.font.escapement } : {}
 	});
 }
+function shiftPrim(prim, dx, dy) {
+	if (prim.kind === "text") return {
+		...prim,
+		x: prim.x + dx,
+		y: prim.y + dy
+	};
+	if (prim.kind === "image") return {
+		...prim,
+		x: prim.x + dx,
+		y: prim.y + dy
+	};
+	return {
+		...prim,
+		paths: prim.paths.map((path) => ({
+			...path,
+			segments: path.segments.map((sg) => "x" in sg ? {
+				...sg,
+				x: sg.x + dx,
+				y: sg.y + dy,
+				..."x1" in sg ? {
+					x1: sg.x1 + dx,
+					y1: sg.y1 + dy
+				} : {},
+				..."x2" in sg ? {
+					x2: sg.x2 + dx,
+					y2: sg.y2 + dy
+				} : {}
+			} : sg)
+		}))
+	};
+}
+/**
+* A primitive mirrored about a horizontal axis, for a window whose y grows UP.
+*
+* Only the geometry turns over. A text run's reference point names a corner of
+* the cell IN DEVICE SPACE — GDI never draws the glyphs themselves upside down —
+* so the point moves and the alignment flags stay as they are. An image states
+* the TOP of its destination rectangle, which after the mirror is where its
+* bottom used to be.
+*
+* @param prim      The primitive, in the metafile's own logical units.
+* @param twiceAxis Twice the y the mirror runs along, so `y' = twiceAxis - y`.
+* @returns The primitive with its y coordinates turned over.
+*/
+function mirrorPrimY(prim, twiceAxis) {
+	const at = (y) => twiceAxis - y;
+	if (prim.kind === "text") return {
+		...prim,
+		y: at(prim.y)
+	};
+	if (prim.kind === "image") return {
+		...prim,
+		y: at(prim.y + prim.height)
+	};
+	return {
+		...prim,
+		paths: prim.paths.map((path) => ({
+			...path,
+			segments: path.segments.map((sg) => "x" in sg ? {
+				...sg,
+				y: at(sg.y),
+				..."y1" in sg ? { y1: at(sg.y1) } : {},
+				..."y2" in sg ? { y2: at(sg.y2) } : {}
+			} : sg)
+		}))
+	};
+}
 function penStyle(style) {
 	switch (style & 15) {
 		case 1: return "dash";

package/dist/esm/core/ole/escher-blip.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The picture bytes inside one Escher BLIP record — a raster as it stands, or a
+ * metafile unpacked out of its header.
+ *
+ * @param type     The blip record type (`0xF01A`…`0xF02A`).
+ * @param instance The record's `recInstance`, which says how many UIDs precede
+ *                 the payload.
+ * @param data     The record's body, without the 8-byte header.
+ * @returns The bytes to hand the renderer, or `undefined` when the blip holds
+ *          nothing this can read.
+ */
+export declare function readEscherBlip(type: number, instance: number, data: Uint8Array): Uint8Array | undefined;

package/dist/esm/core/ole/escher-blip.js

@@ -0,0 +1,98 @@
+import { dibToBmp } from "../bmp.js";
+import { unzlibSync } from "fflate";
+//#region src/core/ole/escher-blip.ts
+var BLIP_EMF = 61466;
+var BLIP_WMF = 61467;
+var BLIP_PICT = 61468;
+var BLIP_JPEG = 61469;
+var BLIP_PNG = 61470;
+var BLIP_DIB = 61471;
+var BLIP_TIFF = 61481;
+var BLIP_JPEG_CMYK = 61482;
+var METAFILE_HEADER_BYTES = 34;
+var COMPRESSION_DEFLATE = 0;
+var TWO_UID_INSTANCES = new Set([
+	981,
+	535,
+	1347,
+	1761,
+	1763,
+	1961,
+	1765,
+	481
+]);
+/** The signatures of the rasters a blip may hold, for the scan fallback. */
+var RASTER_MAGICS = [
+	[
+		137,
+		80,
+		78,
+		71
+	],
+	[
+		255,
+		216,
+		255
+	],
+	[
+		71,
+		73,
+		70,
+		56
+	],
+	[66, 77]
+];
+/**
+* The picture bytes inside one Escher BLIP record — a raster as it stands, or a
+* metafile unpacked out of its header.
+*
+* @param type     The blip record type (`0xF01A`…`0xF02A`).
+* @param instance The record's `recInstance`, which says how many UIDs precede
+*                 the payload.
+* @param data     The record's body, without the 8-byte header.
+* @returns The bytes to hand the renderer, or `undefined` when the blip holds
+*          nothing this can read.
+*/
+function readEscherBlip(type, instance, data) {
+	if (type === BLIP_EMF || type === BLIP_WMF || type === BLIP_PICT) return readMetafileBlip(instance, data);
+	if (type === BLIP_DIB) return readDibBlip(instance, data) ?? scanRaster(data);
+	if (type === BLIP_JPEG || type === BLIP_PNG || type === BLIP_TIFF || type === BLIP_JPEG_CMYK) return scanRaster(data);
+	return scanRaster(data);
+}
+function readDibBlip(instance, data) {
+	const uidBytes = TWO_UID_INSTANCES.has(instance) ? 32 : 16;
+	for (const at of [uidBytes + 1, uidBytes]) {
+		if (data.length <= at) continue;
+		const bmp = dibToBmp(data.subarray(at));
+		if (bmp) return bmp;
+	}
+}
+function readMetafileBlip(instance, data) {
+	const uidBytes = TWO_UID_INSTANCES.has(instance) ? 32 : 16;
+	const head = uidBytes + METAFILE_HEADER_BYTES;
+	if (data.length < head) return void 0;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const uncompressed = view.getUint32(uidBytes, true);
+	const compressed = view.getUint32(uidBytes + 24, true);
+	const compression = data[uidBytes + 32];
+	const payload = data.subarray(head, Math.min(data.length, head + (compressed || Infinity)));
+	if (payload.length === 0) return void 0;
+	if (compression !== COMPRESSION_DEFLATE) return payload;
+	try {
+		const out = unzlibSync(payload, uncompressed > 0 ? { out: new Uint8Array(uncompressed) } : {});
+		return out.length > 0 ? out : void 0;
+	} catch {
+		return;
+	}
+}
+function scanRaster(data) {
+	const limit = Math.min(data.length, 80);
+	for (let off = 0; off < limit; off++) for (const magic of RASTER_MAGICS) if (matches(data, off, magic)) return data.subarray(off);
+}
+function matches(d, off, magic) {
+	if (off + magic.length > d.length) return false;
+	for (let i = 0; i < magic.length; i++) if (d[off + i] !== magic[i]) return false;
+	return true;
+}
+//#endregion
+export { readEscherBlip };

package/dist/esm/{pdf-reader → core}/png-encode.js

@@ -1,5 +1,5 @@
 import { zlibSync } from "fflate";
-//#region src/pdf-reader/png-encode.ts
+//#region src/core/png-encode.ts
 var COLOR_TYPE = {
 	gray: 0,
 	rgb: 2,

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

@@ -101,7 +101,8 @@ var DIGIT_EM = [
 	[/^(arial|helvetica|liberation sans|arimo|arial unicode ms)$/i, 1139 / 2048],
 	[/^(times new roman|liberation serif|tinos)$/i, 1024 / 2048],
 	[/^(tahoma)$/i, 1118 / 2048],
-	[/^(verdana|dejavu sans)$/i, 1303 / 2048]
+	[/^(verdana|dejavu sans)$/i, 1303 / 2048],
+	[/* @__PURE__ */ new RegExp("^(新細明體|細明體|pmingliu|mingliu|標楷體|dfkai-sb|宋体|新宋体|simsun|nsimsun|黑体|simhei|微软雅黑|microsoft yahei|微軟正黑體|microsoft jhenghei|ＭＳ [Ｐ]?明朝|ＭＳ [Ｐ]?ゴシック|ms [p]?mincho|ms [p]?gothic|meiryo|メイリオ|游ゴシック|yu gothic|굴림체?|gulim(che)?|돋움체?|dotum(che)?|바탕체?|batang(che)?|맑은 고딕|malgun gothic)$", "iu"), 1024 / 2048]
 ];
 /**
 * §18.3.1.13 — the Maximum Digit Width, in twips, of the normal style's font.
@@ -1021,6 +1022,7 @@ function runPropsFromXf(xf, styles) {
 	if (font.strike) props.strike = true;
 	if (font.sizePt !== void 0) props.fontSizePt = halfPtToPt(Math.round(font.sizePt * 2));
 	if (font.colorHex) props.colorHex = font.colorHex;
+	if (font.name) props.fontFamily = { ascii: font.name };
 	return props;
 }
 function stackedVerticalContent(text, runProps, href) {
@@ -1120,8 +1122,8 @@ function shadingFromXf(xf, styles) {
 	if (!pattern || pattern === "none") return void 0;
 	if (pattern === "solid") return fill.fgColorHex ? { colorHex: fill.fgColorHex } : void 0;
 	const density = PATTERN_DENSITY[pattern];
-	if (density === void 0 || !fill.fgColorHex) return void 0;
-	const blended = blendHex(fill.fgColorHex, fill.bgColorHex ?? "FFFFFF", density);
+	if (density === void 0) return void 0;
+	const blended = blendHex(fill.fgColorHex ?? "000000", fill.bgColorHex ?? "FFFFFF", density);
 	return blended ? { colorHex: blended } : void 0;
 }
 function blendHex(fg, bg, fraction) {

package/dist/esm/excel/sheet-drawing.js

@@ -162,7 +162,7 @@ function makeColWidthPt(ws) {
 	return (col) => {
 		for (const c of ws.columns) if (col >= c.min - 1 && col <= c.max - 1) return widthPt(c.widthChars);
 		if (ws.defaultColWidthChars !== void 0) return widthPt(ws.defaultColWidthChars);
-		if (ws.baseColWidthChars !== void 0) return (columnTwips(ws.baseColWidthChars, 105) + 75) / TWIPS_PER_PT;
+		if (ws.baseColWidthChars !== void 0) return (columnTwips(ws.baseColWidthChars, 105) + 150) / TWIPS_PER_PT;
 		return 960 / TWIPS_PER_PT;
 	};
 }

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

@@ -401,8 +401,16 @@ function withDrawingsByBand(drawings, gridBody, lefts) {
 	const byBand = lefts.map(() => []);
 	for (const el of drawings) {
 		const x = floatLeftPt(el);
-		const band = x === void 0 ? 0 : bandOf(x);
-		byBand[band].push(x === void 0 ? el : shiftFloatLeft(el, lefts[band]));
+		if (x === void 0) {
+			byBand[0].push(el);
+			continue;
+		}
+		const start = bandOf(x);
+		const right = x + (floatWidthPt(el) ?? 0);
+		for (let band = start; band < lefts.length; band++) {
+			if (band > start && right <= lefts[band]) break;
+			byBand[band].push(shiftFloatLeft(el, lefts[band]));
+		}
 	}
 	const out = [];
 	let seen = 0;
@@ -416,6 +424,12 @@ function withDrawingsByBand(drawings, gridBody, lefts) {
 function floatLeftPt(el) {
 	return (el.kind === "chart" ? el.chart.float : el.kind === "image" ? el.image.float : el.kind === "shape" ? el.shape.float : void 0)?.posH?.offsetPt;
 }
+/** A float's own width, for the block kinds a sheet anchors. */
+function floatWidthPt(el) {
+	if (el.kind === "chart") return el.chart.width;
+	if (el.kind === "image") return el.image.width;
+	if (el.kind === "shape") return el.shape.width;
+}
 /** The same block with its horizontal anchor measured from `by` points later. */
 function shiftFloatLeft(el, by) {
 	if (by === 0) return el;

package/dist/esm/excel/styles-parser.js

@@ -1,7 +1,7 @@
 import { INDEXED_COLORS } from "../core/indexed-colors.js";
 import { applyColorMods } from "../core/drawingml/colors.js";
-import { resolveInternalEntities } from "../core/opc/xml-entities.js";
 import { resolveAlternateContent } from "../core/opc/alternate-content.js";
+import { resolveInternalEntities } from "../core/opc/xml-entities.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/excel/styles-parser.ts
 var decoder = new TextDecoder("utf-8");

package/dist/esm/excel/xls/biff-reader.js

@@ -1,5 +1,6 @@
 import { pt } from "../../core/ir/units.js";
 import { ResourceStore } from "../../core/ir/resources.js";
+import { makeColWidthPt, makeRowHeightPt } from "../sheet-drawing.js";
 import { openCfb } from "../../core/ole/cfb.js";
 import { parseBiffChart } from "./biff-chart.js";
 import { buildBiffPalette, parseBiffStyles } from "./biff-styles.js";
@@ -333,7 +334,8 @@ function readSheet(wb, view, start, blips, resources, sharedStrings, chartData,
 		...pane ? { pane } : {}
 	};
 	const drawing = gatherDrawing(records, REC.MSODRAWING);
-	const images = drawing.length > 0 && blips.length > 0 ? buildImages(drawing, blips, resources) : [];
+	const place = anchorPlacer(grid);
+	const images = drawing.length > 0 && blips.length > 0 ? buildImages(drawing, blips, resources, place) : [];
 	const charts = [];
 	for (let i = 0; i < records.length; i++) {
 		if (records[i].type !== REC.BOF || readU16(records[i].data, 2) !== 32) continue;
@@ -361,7 +363,7 @@ function readSheet(wb, view, start, blips, resources, sharedStrings, chartData,
 		grid,
 		images,
 		charts,
-		shapes: drawing.length > 0 ? buildShapes(parseSheetShapes(drawing), gatherTxoTexts(records)) : [],
+		shapes: drawing.length > 0 ? buildShapes(parseSheetShapes(drawing), gatherTxoTexts(records), place) : [],
 		hyperlinks,
 		comments: parseComments(records)
 	};
@@ -1174,13 +1176,24 @@ function parseComments(records) {
 	}
 	return out;
 }
-function buildShapes(escherShapes, txoTexts) {
+function buildShapes(escherShapes, txoTexts, place) {
 	const out = [];
 	let textIdx = 0;
 	for (const s of escherShapes) {
 		const text = s.hasText ? txoTexts[textIdx++] ?? "" : "";
-		const { widthPt, heightPt } = anchorSize(s.anchor);
+		const { xPt, yPt, widthPt, heightPt } = place(s.anchor);
 		out.push({
+			float: {
+				wrap: "none",
+				posH: {
+					relativeFrom: "margin",
+					offsetPt: pt(xPt)
+				},
+				posV: {
+					relativeFrom: "margin",
+					offsetPt: pt(yPt)
+				}
+			},
 			width: pt(widthPt),
 			height: pt(heightPt),
 			geometry: {
@@ -1222,34 +1235,56 @@ function shapePreset(type) {
 		default: return "rect";
 	}
 }
-function buildImages(drawing, blips, resources) {
+function buildImages(drawing, blips, resources, place) {
 	const out = [];
 	for (const pic of parseSheetPictures(drawing)) {
 		const bytes = blips[pic.blipIndex - 1];
 		if (!bytes) continue;
-		const { widthPt, heightPt } = anchorSize(pic.anchor);
+		const { xPt, yPt, widthPt, heightPt } = place(pic.anchor);
 		out.push({
 			resourceId: resources.put(bytes),
 			widthPt,
-			heightPt
+			heightPt,
+			xPt,
+			yPt
 		});
 	}
 	return out;
 }
-function anchorSize(anchor) {
-	if (!anchor) return {
-		widthPt: 96,
-		heightPt: 72
+function anchorPlacer(grid) {
+	const colPt = makeColWidthPt(grid);
+	const rowPt = makeRowHeightPt(grid);
+	const before = (track) => {
+		const sums = [0];
+		return (index) => {
+			const n = Math.min(Math.max(Math.trunc(index), 0), MAX_ANCHOR_TRACKS);
+			while (sums.length <= n) sums.push(sums[sums.length - 1] + track(sums.length - 1));
+			return sums[n];
+		};
 	};
-	const DEFAULT_COL_PT = 48;
-	const DEFAULT_ROW_PT = 15;
-	const cols = anchor.col2 + anchor.dx2 / 1024 - (anchor.col1 + anchor.dx1 / 1024);
-	const rows = anchor.row2 + anchor.dy2 / 1024 - (anchor.row1 + anchor.dy1 / 1024);
-	return {
-		widthPt: Math.max(8, cols * DEFAULT_COL_PT),
-		heightPt: Math.max(8, rows * DEFAULT_ROW_PT)
+	const beforeCol = before(colPt);
+	const beforeRow = before(rowPt);
+	const at = (index, off, start, track) => start(index) + off / 1024 * track(index);
+	return (anchor) => {
+		if (!anchor) return {
+			xPt: 0,
+			yPt: 0,
+			widthPt: 96,
+			heightPt: 72
+		};
+		const x1 = at(anchor.col1, anchor.dx1, beforeCol, colPt);
+		const x2 = at(anchor.col2, anchor.dx2, beforeCol, colPt);
+		const y1 = at(anchor.row1, anchor.dy1, beforeRow, rowPt);
+		const y2 = at(anchor.row2, anchor.dy2, beforeRow, rowPt);
+		return {
+			xPt: x1,
+			yPt: y1,
+			widthPt: Math.max(1, x2 - x1),
+			heightPt: Math.max(1, y2 - y1)
+		};
 	};
 }
+var MAX_ANCHOR_TRACKS = 65536;
 function numCell(row, column, style, rawValue) {
 	return {
 		column,

package/dist/esm/excel/xls/biff-styles.d.ts

@@ -4,8 +4,11 @@ interface BiffRec {
     readonly data: Uint8Array;
 }
 /**
- * Build a palette-index → `"FFRRGGBB"` (8-hex ARGB, like the xlsx `rgb` attr)
- * resolver from the default 56-colour palette plus any `PALETTE` override.
+ * Build a palette-index → `"RRGGBB"` resolver from the default 56-colour palette
+ * plus any `PALETTE` override. Six hex digits, not the eight an xlsx `rgb`
+ * attribute carries: by the time styles are parsed the alpha is gone, and a
+ * colour that kept it was read from its first six characters — silver `C0C0C0`
+ * reaching the page as the pink `FFC0C0`.
  * `0x7FFF` / 64 / 65 are automatic or system colours → `undefined` (the renderer
  * default). Exported so the conditional-format reader (XLS-13) resolves its dxf
  * colours the same way.

package/dist/esm/excel/xls/biff-styles.js

@@ -116,8 +116,11 @@ var PALETTE56 = [
 	"333333"
 ];
 /**
-* Build a palette-index → `"FFRRGGBB"` (8-hex ARGB, like the xlsx `rgb` attr)
-* resolver from the default 56-colour palette plus any `PALETTE` override.
+* Build a palette-index → `"RRGGBB"` resolver from the default 56-colour palette
+* plus any `PALETTE` override. Six hex digits, not the eight an xlsx `rgb`
+* attribute carries: by the time styles are parsed the alpha is gone, and a
+* colour that kept it was read from its first six characters — silver `C0C0C0`
+* reaching the page as the pink `FFC0C0`.
 * `0x7FFF` / 64 / 65 are automatic or system colours → `undefined` (the renderer
 * default). Exported so the conditional-format reader (XLS-13) resolves its dxf
 * colours the same way.
@@ -130,8 +133,7 @@ function buildBiffPalette(records) {
 	for (const rec of records) if (rec.type === REC_PALETTE) applyPalette(rec.data, palette);
 	return (icv) => {
 		if (icv === 32767 || icv === 64 || icv === 65) return void 0;
-		const rgb = palette[icv];
-		return rgb ? `FF${rgb}` : void 0;
+		return palette[icv];
 	};
 }
 /**
@@ -252,11 +254,11 @@ function parseXf(d, color, internFill, internBorder) {
 	if (right) border.right = right;
 	if (top) border.top = top;
 	if (bottom) border.bottom = bottom;
-	const patternType = FILL_PATTERNS[brd3 >> 26 & 63];
+	const patternType = FILL_PATTERNS[brd3 >> 10 & 63];
 	let fill;
 	if (patternType && patternType !== "none") {
-		const fg = color(brd3 & 127);
-		const bg = color(brd3 >> 7 & 127);
+		const fg = color(brd3 >> 16 & 127);
+		const bg = color(brd3 >> 23 & 127);
 		fill = {
 			patternType,
 			...fg ? { fgColorHex: fg } : {},