xls-codec 4.13.0 → 4.15.0

package/dist/workbook/conditional-format-write.js

@@ -1,4 +1,4 @@
-import "../biff/record-types.js";
+import { RECORD_CF12, RECORD_CONDFMT12 } from "../biff/record-types.js";
 import { RecordBuilder } from "../biff/builder.js";
 import { BiffWriteError } from "../biff/write-errors.js";
 import { writeRecord } from "../biff/record-writer.js";
@@ -65,28 +65,317 @@ function boundingBoxOf(rule) {
 		endColumn
 	};
 }
+const CT_FORMULA = 2;
+const CT_COLOR_SCALE = 3;
+const CT_DATA_BAR = 4;
+const CT_FILTER = 5;
+const CT_ICON_SET = 6;
+const ICF_TEMPLATE_COLOR_SCALE = 2;
+const ICF_TEMPLATE_DATA_BAR = 3;
+const ICF_TEMPLATE_ICON_SET = 4;
+const ICF_TEMPLATE_FILTER = 5;
+const ICF_TEMPLATE_UNIQUE_VALUES = 7;
+const ICF_TEMPLATE_CONTAINS_TEXT = 8;
+const ICF_TEMPLATE_CONTAINS_BLANKS = 9;
+const ICF_TEMPLATE_CONTAINS_NO_BLANKS = 10;
+const ICF_TEMPLATE_CONTAINS_ERRORS = 11;
+const ICF_TEMPLATE_CONTAINS_NO_ERRORS = 12;
+const ICF_TEMPLATE_ABOVE_AVERAGE = 25;
+const ICF_TEMPLATE_BELOW_AVERAGE = 26;
+const ICF_TEMPLATE_DUPLICATE_VALUES = 27;
+const ICF_TEMPLATE_ABOVE_OR_EQUAL_AVERAGE = 29;
+const ICF_TEMPLATE_BELOW_OR_EQUAL_AVERAGE = 30;
+const TEMPLATE_PARAMS_SIZE = 16;
+function cfvoTypeCodeOf(value) {
+	switch (value.type) {
+		case "num": return 1;
+		case "min": return 2;
+		case "max": return 3;
+		case "percent": return 4;
+		case "percentile": return 5;
+		case "formula": return 7;
+		default: return;
+	}
+}
+function writeCfvo(value) {
+	const cfvoType = cfvoTypeCodeOf(value);
+	if (cfvoType === void 0) throw new BiffWriteError(`internal error: ContentSheetConditionalFormatValue carries type "${value.type}", which cfvoTypeCodeOf has no [MS-XLS] 2.5.40 cfvoType code for`);
+	if (value.type === "min" || value.type === "max") return new RecordBuilder().u8(cfvoType).u16(0).build();
+	if (value.value === void 0) throw new BiffWriteError(`a conditional-format threshold of type "${value.type}" carries no value; the shared schema states a value for every type but "min" and "max", and a CFVO has no spelling for a valueless threshold of any other kind`);
+	const rgce = compileFormulaText(value.value);
+	return new RecordBuilder().u8(cfvoType).u16(rgce.length).bytes(rgce).build();
+}
+function writeCfColor(color) {
+	return new RecordBuilder().u32(2).u8(Math.round(color.r * 255)).u8(Math.round(color.g * 255)).u8(Math.round(color.b * 255)).u8(0).f64(0).build();
+}
+function writeCfGradient(rule) {
+	const count = rule.stops.length;
+	const interpFractions = count === 3 ? [
+		0,
+		.5,
+		1
+	] : [0, 1];
+	const out = new RecordBuilder().u16(0).u8(0).u8(count).u8(count).u8(3);
+	rule.stops.forEach((stop, index) => {
+		out.bytes(writeCfvo(stop.value)).f64(interpFractions[index] ?? 1);
+	});
+	rule.stops.forEach((stop, index) => {
+		out.f64(interpFractions[index] ?? 1).bytes(writeCfColor(stop.color));
+	});
+	return out.build();
+}
+function writeCfDatabar(rule) {
+	return new RecordBuilder().u16(0).u8(0).u8(rule.showValue === false ? 0 : 2).u8(0).u8(100).bytes(writeCfColor(rule.color)).bytes(writeCfvo(rule.min)).bytes(writeCfvo(rule.max)).build();
+}
+function iconSetThresholdCount(iIconSet) {
+	if (iIconSet <= 7) return 3;
+	if (iIconSet <= 12) return 4;
+	return 5;
+}
+const ICON_SET_TYPE_NAMES = [
+	"3Arrows",
+	"3ArrowsGray",
+	"3Flags",
+	"3TrafficLights1",
+	"3TrafficLights2",
+	"3Signs",
+	"3Symbols",
+	"3Symbols2",
+	"4Arrows",
+	"4ArrowsGray",
+	"4RedToBlack",
+	"4Rating",
+	"4TrafficLights",
+	"5Arrows",
+	"5ArrowsGray",
+	"5Rating",
+	"5Quarters"
+];
+function writeCfMultistate(rule) {
+	const iIconSet = ICON_SET_TYPE_NAMES.indexOf(rule.iconSetType);
+	if (iIconSet < 0) throw new BiffWriteError(`xls-codec cannot write an icon-set rule naming the icon set "${rule.iconSetType}": [MS-XLS] 2.5.36's own iIconSet table names exactly the seventeen built-in sets, and a custom set has no BIFF8 byte to be written as`);
+	const expectedThresholds = iconSetThresholdCount(iIconSet);
+	if (rule.thresholds.length !== expectedThresholds) throw new BiffWriteError(`an icon-set rule naming the icon set "${rule.iconSetType}" carries ${rule.thresholds.length} thresholds where [MS-XLS] 2.5.36's own cStates table fixes the set at ${expectedThresholds}; the threshold count and the set cannot disagree in one CFMultistate`);
+	const out = new RecordBuilder().u16(0).u8(0).u8(expectedThresholds).u8(iIconSet).u8((rule.showValue === false ? 1 : 0) | (rule.reverse === true ? 4 : 0));
+	for (const threshold of rule.thresholds) {
+		out.bytes(writeCfvo(threshold)).u8(0);
+		out.u32(0);
+	}
+	return out.build();
+}
+function writeCfFilter(top10) {
+	const flags = top10 === void 0 ? 0 : (top10.bottom === true ? 0 : 1) | (top10.percent === true ? 2 : 0);
+	return new RecordBuilder().u16(4).u8(0).u8(flags).u16(top10?.rank ?? 0).build();
+}
+const TIME_PERIOD_TO_ICF_TEMPLATE = /* @__PURE__ */ new Map([
+	["today", 15],
+	["tomorrow", 16],
+	["yesterday", 17],
+	["last7Days", 18],
+	["lastMonth", 19],
+	["nextMonth", 20],
+	["thisWeek", 21],
+	["nextWeek", 22],
+	["lastWeek", 23],
+	["thisMonth", 24]
+]);
+const SIMPLE_KIND_TO_ICF_TEMPLATE = /* @__PURE__ */ new Map([
+	["containsBlanks", ICF_TEMPLATE_CONTAINS_BLANKS],
+	["notContainsBlanks", ICF_TEMPLATE_CONTAINS_NO_BLANKS],
+	["containsErrors", ICF_TEMPLATE_CONTAINS_ERRORS],
+	["notContainsErrors", ICF_TEMPLATE_CONTAINS_NO_ERRORS],
+	["uniqueValues", ICF_TEMPLATE_UNIQUE_VALUES],
+	["duplicateValues", ICF_TEMPLATE_DUPLICATE_VALUES]
+]);
+const CTP_BY_TEXT_TYPE = /* @__PURE__ */ new Map([
+	["containsText", 0],
+	["notContainsText", 1],
+	["beginsWith", 2],
+	["endsWith", 3]
+]);
+function textRuleFormula(rule) {
+	const anchor = rule.ranges[0];
+	if (anchor === void 0) throw new BiffWriteError("internal error: textRuleFormula was called for a rule whose ranges were never validated");
+	const cell = relativeCellRef(anchor.startRow, anchor.startColumn);
+	const text = `"${rule.text.replaceAll("\"", "\"\"")}"`;
+	switch (rule.type) {
+		case "containsText": return `NOT(ISERROR(SEARCH(${text},${cell})))`;
+		case "notContainsText": return `ISERROR(SEARCH(${text},${cell}))`;
+		case "beginsWith": return `LEFT(${cell},LEN(${text}))=${text}`;
+		case "endsWith": return `RIGHT(${cell},LEN(${text}))=${text}`;
+	}
+}
+function relativeCellRef(row, column) {
+	let letters = "";
+	let index = column;
+	do {
+		letters = String.fromCharCode(65 + index % 26) + letters;
+		index = Math.floor(index / 26) - 1;
+	} while (index >= 0);
+	return `${letters}${row + 1}`;
+}
+function writeCf12Record(rule, ipriority, icvOf) {
+	let ct;
+	let icfTemplate;
+	let templateParams;
+	let rgbCt;
+	let rgce1;
+	let dxf;
+	switch (rule.type) {
+		case "colorScale":
+			ct = CT_COLOR_SCALE;
+			icfTemplate = ICF_TEMPLATE_COLOR_SCALE;
+			templateParams = new Uint8Array(TEMPLATE_PARAMS_SIZE);
+			rgbCt = writeCfGradient(rule);
+			dxf = /* @__PURE__ */ new Uint8Array(0);
+			break;
+		case "dataBar":
+			ct = CT_DATA_BAR;
+			icfTemplate = ICF_TEMPLATE_DATA_BAR;
+			templateParams = new Uint8Array(TEMPLATE_PARAMS_SIZE);
+			rgbCt = writeCfDatabar(rule);
+			dxf = /* @__PURE__ */ new Uint8Array(0);
+			break;
+		case "iconSet":
+			ct = CT_ICON_SET;
+			icfTemplate = ICF_TEMPLATE_ICON_SET;
+			templateParams = new Uint8Array(TEMPLATE_PARAMS_SIZE);
+			rgbCt = writeCfMultistate(rule);
+			dxf = /* @__PURE__ */ new Uint8Array(0);
+			break;
+		case "top10":
+			ct = CT_FILTER;
+			icfTemplate = ICF_TEMPLATE_FILTER;
+			templateParams = new RecordBuilder().u8((rule.bottom === true ? 0 : 1) | (rule.percent === true ? 2 : 0)).u16(rule.rank).bytes(/* @__PURE__ */ new Uint8Array(13)).build();
+			rgbCt = writeCfFilter(rule);
+			dxf = writeDxfn(rule.style, icvOf);
+			break;
+		case "aboveAverage": {
+			ct = CT_FILTER;
+			icfTemplate = !(rule.aboveAverage ?? true) ? rule.equalAverage === true ? ICF_TEMPLATE_BELOW_OR_EQUAL_AVERAGE : ICF_TEMPLATE_BELOW_AVERAGE : rule.equalAverage === true ? ICF_TEMPLATE_ABOVE_OR_EQUAL_AVERAGE : ICF_TEMPLATE_ABOVE_AVERAGE;
+			const stdDev = rule.stdDev ?? 0;
+			if (stdDev > 2) throw new BiffWriteError(`an aboveAverage rule declaring ${stdDev} standard deviations cannot be written: [MS-XLS] 2.5.23's own iParam table admits only 0, 1, or 2`);
+			templateParams = new RecordBuilder().u16(stdDev).bytes(/* @__PURE__ */ new Uint8Array(14)).build();
+			rgbCt = writeCfFilter(void 0);
+			dxf = writeDxfn(rule.style, icvOf);
+			break;
+		}
+		case "timePeriod": {
+			ct = CT_FILTER;
+			const template = TIME_PERIOD_TO_ICF_TEMPLATE.get(rule.timePeriod);
+			if (template === void 0) throw new BiffWriteError(`a timePeriod rule naming "${rule.timePeriod}" cannot be written: that member exists only in LibreOffice's calcext extension vocabulary ([MS-XLS] 2.4.43's own icfTemplate table has no year-scoped period), so no BIFF8 rule names it`);
+			icfTemplate = template;
+			templateParams = new RecordBuilder().u16(template).bytes(/* @__PURE__ */ new Uint8Array(14)).build();
+			rgbCt = writeCfFilter(void 0);
+			dxf = writeDxfn(rule.style, icvOf);
+			break;
+		}
+		case "containsBlanks":
+		case "notContainsBlanks":
+		case "containsErrors":
+		case "notContainsErrors":
+		case "uniqueValues":
+		case "duplicateValues": {
+			ct = CT_FILTER;
+			const template = SIMPLE_KIND_TO_ICF_TEMPLATE.get(rule.type);
+			if (template === void 0) throw new BiffWriteError(`internal error: SIMPLE_KIND_TO_ICF_TEMPLATE has no icfTemplate for rule type "${rule.type}"`);
+			icfTemplate = template;
+			templateParams = new Uint8Array(TEMPLATE_PARAMS_SIZE);
+			rgbCt = writeCfFilter(void 0);
+			dxf = writeDxfn(rule.style, icvOf);
+			break;
+		}
+		case "containsText":
+		case "notContainsText":
+		case "beginsWith":
+		case "endsWith": {
+			ct = CT_FORMULA;
+			icfTemplate = ICF_TEMPLATE_CONTAINS_TEXT;
+			const ctp = CTP_BY_TEXT_TYPE.get(rule.type);
+			if (ctp === void 0) throw new BiffWriteError(`internal error: CTP_BY_TEXT_TYPE has no ctp for rule type "${rule.type}"`);
+			templateParams = new RecordBuilder().u16(ctp).bytes(/* @__PURE__ */ new Uint8Array(14)).build();
+			rgce1 = compileFormulaText(textRuleFormula(rule));
+			dxf = writeDxfn(rule.style, icvOf);
+			break;
+		}
+		default: throw new BiffWriteError("internal error: writeCf12Record was called for a rule type its own dispatch never names");
+	}
+	const writer = new RecordBuilder().u16(RECORD_CF12).u16(0).bytes(/* @__PURE__ */ new Uint8Array(8)).u8(ct).u8(0).u16(rgce1?.length ?? 0).u16(0).u32(dxf.length).bytes(dxf);
+	if (rgce1 !== void 0) writer.bytes(rgce1);
+	writer.u16(0).u8(rule.stopIfTrue === true ? 2 : 0).u16(ipriority).u16(icfTemplate).u8(TEMPLATE_PARAMS_SIZE).bytes(templateParams);
+	if (rgbCt !== void 0) writer.bytes(rgbCt);
+	return writeRecord(RECORD_CF12, writer.build());
+}
+function assignPriorities(rules) {
+	const used = /* @__PURE__ */ new Set();
+	for (const rule of rules) {
+		if (rule.priority === void 0) continue;
+		if (used.has(rule.priority)) throw new BiffWriteError(`two conditional-format rules declare priority ${rule.priority}; [MS-XLS] 2.4.43 requires ipriority to be unique across a sheet's CF12 records, so a document repeating one is contradictory rather than orderable`);
+		used.add(rule.priority);
+	}
+	return rules.map((rule) => {
+		if (rule.priority !== void 0) return rule.priority;
+		let candidate = 1;
+		while (used.has(candidate)) candidate += 1;
+		used.add(candidate);
+		return candidate;
+	});
+}
+function writeCondFmt12Record(rule, nID) {
+	const box = boundingBoxOf(rule);
+	const header = new RecordBuilder().u16(RECORD_CONDFMT12).u16(1).u16(box.startRow).u16(box.endRow).u16(box.startColumn).u16(box.endColumn).u16(1).u16(nID << 1).u16(box.startRow).u16(box.endRow).u16(box.startColumn).u16(box.endColumn).u16(rule.ranges.length);
+	for (const range of rule.ranges) {
+		header.u16(range.startRow);
+		header.u16(range.endRow);
+		header.u16(range.startColumn);
+		header.u16(range.endColumn);
+	}
+	return writeRecord(RECORD_CONDFMT12, header.build());
+}
+function validateRuleGrid(rule) {
+	if (rule.ranges.length === 0) throw new BiffWriteError("a conditional-format rule carrying no range states nothing; the schema requires at least one");
+	for (const range of rule.ranges) if (range.startRow > 65535 || range.endRow > 65535 || range.startColumn > 255 || range.endColumn > 255) throw new BiffWriteError(`a conditional-format range (rows ${range.startRow}-${range.endRow}, columns ${range.startColumn}-${range.endColumn}) is outside BIFF8's own grid; a .xls workbook cannot address it`);
+}
+function validateStopIfTrue(rule) {
+	if (rule.stopIfTrue === true && (rule.type === "colorScale" || rule.type === "dataBar" || rule.type === "iconSet")) throw new BiffWriteError(`a conditional-format rule of type "${rule.type}" declaring stopIfTrue cannot be written: [MS-XLS] 2.4.43 pins CF12's own fStopIfTrue bit to zero for the visual-scale rule types`);
+}
 function writeSheetConditionalFormats(sheet, icvOf) {
 	const rules = sheet.conditionalFormats ?? [];
 	if (rules.length === 0) return [];
-	const pieces = [];
-	for (const [index, rule] of rules.entries()) {
-		if (rule.type !== "cellIs") throw new BiffWriteError(`a conditional-format rule of type "${rule.type}" has no base BIFF8 CF spelling; this writer states cellIs comparisons only (CF12 writing is out of scope), so the rule cannot be written rather than silently dropped`);
-		if (rule.ranges.length === 0) throw new BiffWriteError("a conditional-format rule carrying no range states nothing; the schema requires at least one");
-		for (const range of rule.ranges) if (range.startRow > 65535 || range.endRow > 65535 || range.startColumn > 255 || range.endColumn > 255) throw new BiffWriteError(`a conditional-format range (rows ${range.startRow}-${range.endRow}, columns ${range.startColumn}-${range.endColumn}) is outside BIFF8's own grid; a .xls workbook cannot address it`);
-		const nID = index + 1;
-		if (nID > 32767) throw new BiffWriteError(`this sheet's ${rules.length} conditional-format rules exceed CondFmt's own 15-bit nID field`);
-		const box = boundingBoxOf(rule);
-		const header = new RecordBuilder().u16(1).u16(nID << 1).u16(box.startRow).u16(box.endRow).u16(box.startColumn).u16(box.endColumn).u16(rule.ranges.length);
-		for (const range of rule.ranges) {
-			header.u16(range.startRow);
-			header.u16(range.endRow);
-			header.u16(range.startColumn);
-			header.u16(range.endColumn);
+	const basePieces = [];
+	const cf12Pieces = [];
+	if (rules.length > 32767) throw new BiffWriteError(`this sheet's ${rules.length} conditional-format rules exceed CondFmt's own 15-bit nID field`);
+	const cf12Rules = [];
+	rules.forEach((rule, index) => {
+		validateRuleGrid(rule);
+		if (rule.type === "cellIs") {
+			basePieces.push(writeCondFmtRecord(rule, index + 1), writeCfRecord(rule, icvOf));
+			return;
 		}
-		pieces.push(writeRecord(432, header.build()));
-		pieces.push(writeCfRecord(rule, icvOf));
+		validateStopIfTrue(rule);
+		cf12Rules.push({
+			rule,
+			nID: index + 1
+		});
+	});
+	const priorities = assignPriorities(cf12Rules.map(({ rule }) => rule));
+	cf12Rules.forEach(({ rule, nID }, index) => {
+		const ipriority = priorities[index];
+		if (ipriority === void 0) throw new BiffWriteError("internal error: assignPriorities returned fewer priorities than there are CF12 rules");
+		cf12Pieces.push(writeCondFmt12Record(rule, nID), writeCf12Record(rule, ipriority, icvOf));
+	});
+	return [...basePieces, ...cf12Pieces];
+}
+function writeCondFmtRecord(rule, nID) {
+	const box = boundingBoxOf(rule);
+	const header = new RecordBuilder().u16(1).u16(nID << 1).u16(box.startRow).u16(box.endRow).u16(box.startColumn).u16(box.endColumn).u16(rule.ranges.length);
+	for (const range of rule.ranges) {
+		header.u16(range.startRow);
+		header.u16(range.endRow);
+		header.u16(range.startColumn);
+		header.u16(range.endColumn);
 	}
-	return pieces;
+	return writeRecord(432, header.build());
 }
 //#endregion
 export { writeSheetConditionalFormats };

package/dist/workbook/drawing-writer.cjs

@@ -0,0 +1,253 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../biff/record-types.cjs");
+const require_units = require("../units.cjs");
+const require_biff_builder = require("../biff/builder.cjs");
+const require_biff_write_errors = require("../biff/write-errors.cjs");
+const require_biff_record_writer = require("../biff/record-writer.cjs");
+const require_biff_string_writer = require("../biff/string-writer.cjs");
+const require_workbook_embedded_object = require("./embedded-object.cjs");
+const require_drawing_escher_writer = require("../drawing/escher-writer.cjs");
+//#region src/workbook/drawing-writer.ts
+/** The sheet-grid geometry an anchor resolves against and inverts into, the write-side mirror of workbook/drawing.ts's own SheetGridGeometry: declared column widths/row heights with the same Excel "Normal" defaults beneath, so a shape written from a given placement reads back at the identical placement. Derived from the same constants (units.ts) the reader's own geometry uses, so the two cannot disagree about what an undeclared cell sizes. */
+var WriterGridGeometry = class {
+	columnWidths = /* @__PURE__ */ new Map();
+	rowHeights = /* @__PURE__ */ new Map();
+	defaultColumnWidthPt = require_units.columnWidthToPoints(require_units.DEFAULT_COLUMN_WIDTH_CHARS * 256);
+	constructor(sheet) {
+		for (const column of sheet.columns) if (column.widthPt !== void 0) this.columnWidths.set(column.index, column.widthPt);
+		for (const row of sheet.rows) if (row.heightPt !== void 0) this.rowHeights.set(row.index, row.heightPt);
+	}
+	columnWidthPt(index) {
+		return this.columnWidths.get(index) ?? this.defaultColumnWidthPt;
+	}
+	rowHeightPt(index) {
+		return this.rowHeights.get(index) ?? 15;
+	}
+	/** The absolute x of a column's own left edge -- the cumulative width of every column before it, the identical accumulation the reader's own geometry walks back down. */
+	xPt(column) {
+		let x = 0;
+		for (let index = 0; index < column; index += 1) x += this.columnWidthPt(index);
+		return x;
+	}
+	yPt(row) {
+		let y = 0;
+		for (let index = 0; index < row; index += 1) y += this.rowHeightPt(index);
+		return y;
+	}
+	/** Locates an absolute x as a column plus a 1/1024ths-of-that-column fraction, the pair OfficeArtClientAnchorSheet's own left/right corners state. A point beyond the grid's own last column clamps to that column's far edge: the grid has no column 256 to name, and a shape whose extent runs that far past the grid loses only the overflow, where refusing the workbook would lose the cells too -- the same trade a print range past the grid already draws (print-names.ts's clampToGrid). */
+	locateX(x) {
+		let left = 0;
+		for (let column = 0; column < 255; column += 1) {
+			const width = this.columnWidthPt(column);
+			if (x < left + width) return {
+				column,
+				fraction: Math.min(1023, Math.round((x - left) / width * 1024))
+			};
+			left += width;
+		}
+		return {
+			column: 255,
+			fraction: 1023
+		};
+	}
+	/** The row-axis counterpart: a row plus a 1/256ths-of-that-row fraction, clamped to the grid's own last row. */
+	locateY(y) {
+		let top = 0;
+		for (let row = 0; row < 65535; row += 1) {
+			const height = this.rowHeightPt(row);
+			if (y < top + height) return {
+				row,
+				fraction: Math.min(255, Math.round((y - top) / height * 256))
+			};
+			top += height;
+		}
+		return {
+			row: 65535,
+			fraction: 255
+		};
+	}
+};
+function placementOfImage(image, geometry) {
+	if (image.anchorRow > 65535 || image.anchorColumn > 255) throw new require_biff_write_errors.BiffWriteError(`a sheet image anchored at row ${image.anchorRow}, column ${image.anchorColumn} is outside BIFF8's own grid (rows 0-65535, columns 0-255); a .xls workbook cannot address the cell it names`);
+	return {
+		startXPt: geometry.xPt(image.anchorColumn) + image.offsetXPt,
+		startYPt: geometry.yPt(image.anchorRow) + image.offsetYPt,
+		widthPt: image.widthPt,
+		heightPt: image.heightPt
+	};
+}
+function placementOfEmbedded(embedded, geometry) {
+	return {
+		startXPt: embedded.anchorColumn !== void 0 && embedded.offsetXPt !== void 0 ? geometry.xPt(embedded.anchorColumn) + embedded.offsetXPt : embedded.frame.xPt,
+		startYPt: embedded.anchorRow !== void 0 && embedded.offsetYPt !== void 0 ? geometry.yPt(embedded.anchorRow) + embedded.offsetYPt : embedded.frame.yPt,
+		widthPt: embedded.frame.widthPt,
+		heightPt: embedded.frame.heightPt
+	};
+}
+/** Inverts a placement into the OfficeArtClientAnchorSheet corner pair the reader's own resolveAnchorPlacement turns back into that placement: each corner resolved to its containing cell and a 1/1024ths (columns) or 1/256ths (rows) fraction within it. */
+function anchorOf(placement, geometry) {
+	const start = geometry.locateX(placement.startXPt);
+	const end = geometry.locateX(placement.startXPt + placement.widthPt);
+	const top = geometry.locateY(placement.startYPt);
+	const bottom = geometry.locateY(placement.startYPt + placement.heightPt);
+	return {
+		colL: start.column,
+		dxL: start.fraction,
+		rwT: top.row,
+		dyT: top.fraction,
+		colR: end.column,
+		dxR: end.fraction,
+		rwB: bottom.row,
+		dyB: bottom.fraction
+	};
+}
+/** [MS-XLS] 2.5.213's own ot table: the Picture type both a plain image and an embedded OLE object carry -- an OLE object IS hosted through the picture machinery (its FtPictFmla naming the Embedding Storage its data lives in), which is exactly how the Embedding Storage page itself states the pairing ("cmo.ot equal to 8, pictFlags.fPrstm equal to 0, and pictFlags.fDde equal to 0"). */
+const OBJECT_TYPE_PICTURE = 8;
+/** FtCmo ([MS-XLS] 2.5.92, 22 bytes): ft 0x15, cb 0x12, the object type and id, then grbit and three unused dwords all written zero -- the identical shape comment-writer.ts writes for a Note, restated here with the object type as a parameter rather than shared across the two direction modules. */
+function writeFtCmo(ot, id) {
+	return new require_biff_builder.RecordBuilder().u16(21).u16(18).u16(ot).u16(id).u16(0).u32(0).u32(0).u32(0).build();
+}
+/** FtCf ([MS-XLS] 2.5.142, https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-xls/fc5bb3ce-8e35-4393-b22f-9cf54062a3a4): the clipboard format of the picture this object shows. 0xFFFF names "an unspecified format that is neither an enhanced metafile nor a bitmap" -- honest for a shape whose visible rendering is the blip the Escher layer itself carries and for an OLE object this writer has no preview metafile for. */
+function writeFtCf() {
+	return new require_biff_builder.RecordBuilder().u16(7).u16(2).u16(65535).build();
+}
+/** FtPioGrbit ([MS-XLS] 2.5.151, https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-xls/8eee0b3d-9d27-4294-85fc-a66ae8a361c9): a plain picture states fAutoPict (aspect preserved across views); an OLE embedding states no bits at all -- fPrstm and fDde stay clear, the pair the Embedding Storage page requires for storage-based object data. */
+function writeFtPioGrbit(autoPict) {
+	return new require_biff_builder.RecordBuilder().u16(8).u16(2).u16(autoPict ? 1 : 0).build();
+}
+/** The PtgTbl token byte an embedded object's ObjectParsedFormula carries ([MS-XLS] 2.5.198.92: ptg 0x02, class none) -- the spelling that tells a reader this picture's data lives in an Embedding Storage rather than a linked range. */
+const PTG_TBL = 2;
+/** The class name stated in an embedding's PictFmlaEmbedInfo: "Package" is what a genuine OLE Package embed carries, so a real OLE-aware consumer that cannot decode this package's own JSON payload still sees a recognisable, accurate class rather than an invented one -- the identical choice rtf-codec's own ObjectHeader makes for the same payload shape. */
+const EMBED_CLASS_NAME = "Package";
+/** FtPictFmla ([MS-XLS] 2.5.150, https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-xls/00f89d32-67b0-408e-9eaf-f4fecbddb089) for an embedded OLE object: the ObjFmla (cbFmla counting the ObjectParsedFormula, the PictFmlaEmbedInfo, and the padding -- even, per [MS-XLS] 2.5.187's own cbFmla rule), then lPosInCtlStm, the storage id the Embedding Storage's own MBD name is the eight-hex-digit spelling of. The ObjectParsedFormula is the one shape [MS-XLS] pins for an embedding: cce 5, rgce one PtgTbl followed by four undefined bytes. */
+function writeFtPictFmla(storageId) {
+	const formula = new require_biff_builder.RecordBuilder().u16(5).u32(0).u8(PTG_TBL).bytes(/* @__PURE__ */ new Uint8Array(4)).build();
+	const className = require_biff_string_writer.writeXLUnicodeStringNoCch(EMBED_CLASS_NAME);
+	const embedInfo = new require_biff_builder.RecordBuilder().u8(3).u8(className.length - 1).u8(0).bytes(className).build();
+	const fmlaBytes = new require_biff_builder.RecordBuilder().bytes(formula).bytes(embedInfo).build();
+	const data = new require_biff_builder.RecordBuilder().u16(fmlaBytes.length).bytes(fmlaBytes).u32(storageId).build();
+	return new require_biff_builder.RecordBuilder().u16(9).u16(data.length).bytes(data).build();
+}
+/** The trailing four reserved bytes every Obj not naming a list-box/dropdown object carries ([MS-XLS] 2.4.181's own reserved field: MUST be 0) -- the ftEnd marker a real sub-record walk terminates on. */
+const OBJ_RESERVED_END = /* @__PURE__ */ new Uint8Array(4);
+/** One picture shape's Obj record: FtCmo (ot Picture), FtCf, FtPioGrbit, and the trailing reserved field. No FtPictFmla -- the image's bytes live in the workbook's Blip Store, which the shape's own pib property names, leaving the Obj record itself nothing to locate. */
+function writePictureObjRecord(objectId) {
+	return require_biff_record_writer.writeRecord(93, new require_biff_builder.RecordBuilder().bytes(writeFtCmo(OBJECT_TYPE_PICTURE, objectId)).bytes(writeFtCf()).bytes(writeFtPioGrbit(true)).bytes(OBJ_RESERVED_END).build());
+}
+/** One embedded OLE object's Obj record: FtCmo (ot Picture), FtCf, FtPioGrbit (no bits -- storage-based, per the Embedding Storage page's own fPrstm/fDde requirement), the FtPictFmla naming the storage, and the trailing reserved field. */
+function writeEmbeddedObjRecord(objectId, storageId) {
+	return require_biff_record_writer.writeRecord(93, new require_biff_builder.RecordBuilder().bytes(writeFtCmo(OBJECT_TYPE_PICTURE, objectId)).bytes(writeFtCf()).bytes(writeFtPioGrbit(false)).bytes(writeFtPictFmla(storageId)).bytes(OBJ_RESERVED_END).build());
+}
+/** Base64's own character set, decoded by hand rather than through atob's DOM-string round trip -- mirroring drawing/blips.ts's own hand-written encoder, which exists for the identical reason: byte-exact, allocation-predictable, and identical in Node and a Workers isolate. */
+function bytesFromBase64(base64) {
+	const values = (/* @__PURE__ */ new Int8Array(256)).fill(-1);
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("").forEach((char, index) => {
+		values[char.charCodeAt(0)] = index;
+	});
+	const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+	const out = new Uint8Array(base64.length / 4 * 3 - padding);
+	let buffer = 0;
+	let bits = 0;
+	let outIndex = 0;
+	for (const char of base64) {
+		const value = values[char.charCodeAt(0)];
+		if (value === void 0 || value < 0) continue;
+		buffer = buffer << 6 | value;
+		bits += 6;
+		if (bits >= 8) {
+			bits -= 8;
+			out[outIndex] = buffer >> bits & 255;
+			outIndex += 1;
+		}
+	}
+	return out;
+}
+function buildDrawingWritePlan(sheets) {
+	const blips = [];
+	const blipIndexByBase64 = /* @__PURE__ */ new Map();
+	const resolveBlip = (image) => {
+		if (image.format !== "png" && image.format !== "jpeg") throw new require_biff_write_errors.BiffWriteError(`xls-codec cannot write a sheet image of format "${image.format}": [MS-ODRAW]'s own MSOBLIPTYPE enumeration has no member for it, so no Blip Store entry can carry it`);
+		const existing = blipIndexByBase64.get(image.base64);
+		if (existing !== void 0) {
+			const blip = blips[existing - 1];
+			if (blip === void 0) throw new require_biff_write_errors.BiffWriteError("internal error: a blip index resolved that the workbook-wide image scan never assigned");
+			blip.referenceCount += 1;
+			return existing;
+		}
+		const index = blips.length + 1;
+		blipIndexByBase64.set(image.base64, index);
+		blips.push({
+			format: image.format,
+			fileBytes: bytesFromBase64(image.base64),
+			referenceCount: 1
+		});
+		return index;
+	};
+	let nextStorageId = 1;
+	const storageIdOf = () => {
+		const id = nextStorageId;
+		nextStorageId += 1;
+		return id;
+	};
+	let nextSpid = 1024;
+	let nextDrawingId = 1;
+	const drawingBlocks = [];
+	const sheetDrawings = [];
+	const embeddingStreams = [];
+	for (const sheet of sheets) {
+		const geometry = new WriterGridGeometry(sheet);
+		const entries = [];
+		const objRecords = [];
+		let nextObjectId = sheet.cells.filter((cell) => cell.comment !== void 0).length + 1;
+		for (const image of sheet.images) {
+			entries.push({
+				anchor: anchorOf(placementOfImage(image, geometry), geometry),
+				blipIndex: resolveBlip(image),
+				oleShape: false
+			});
+			objRecords.push(writePictureObjRecord(nextObjectId));
+			nextObjectId += 1;
+		}
+		for (const embedded of sheet.embeddedObjects ?? []) {
+			if (embedded.objectKind === "chart") throw new require_biff_write_errors.BiffWriteError("xls-codec cannot write a 'chart' embedded object: embedding one means writing a genuine BIFF8 chart substream -- the whole [MS-XLS] chart grammar its series data links drive -- which is a chart engine of its own rather than a container for the flattened series table the schema carries");
+			const storageId = storageIdOf();
+			entries.push({
+				anchor: anchorOf(placementOfEmbedded(embedded, geometry), geometry),
+				blipIndex: void 0,
+				oleShape: true
+			});
+			objRecords.push(writeEmbeddedObjRecord(nextObjectId, storageId));
+			nextObjectId += 1;
+			embeddingStreams.push({
+				path: `MBD${storageId.toString(16).toUpperCase().padStart(8, "0")}/Package`,
+				bytes: require_workbook_embedded_object.writeEmbeddedObjectPackage(embedded)
+			});
+		}
+		if (entries.length === 0) {
+			sheetDrawings.push({
+				msoDrawingRecords: [],
+				objRecords: []
+			});
+			continue;
+		}
+		const escherBytes = require_drawing_escher_writer.writeSheetDrawingBytes(nextDrawingId, nextSpid, entries);
+		drawingBlocks.push({
+			drawingId: nextDrawingId,
+			lastSpid: nextSpid + entries.length,
+			shapeCount: entries.length + 1
+		});
+		nextDrawingId += 1;
+		nextSpid += entries.length + 1;
+		sheetDrawings.push({
+			msoDrawingRecords: require_biff_record_writer.writeRecordChain(236, escherBytes),
+			objRecords
+		});
+	}
+	return {
+		drawingGroupBytes: drawingBlocks.length > 0 ? require_drawing_escher_writer.writeDrawingGroupBytes(blips, drawingBlocks) : void 0,
+		sheetDrawings,
+		embeddingStreams
+	};
+}
+//#endregion
+exports.buildDrawingWritePlan = buildDrawingWritePlan;

package/dist/workbook/drawing-writer.d.cts

@@ -0,0 +1,2 @@
+import { n as SheetDrawingWrite, r as buildDrawingWritePlan, t as DrawingWritePlan } from "../drawing-writer-Blm_NUSZ.cjs";
+export { DrawingWritePlan, SheetDrawingWrite, buildDrawingWritePlan };

package/dist/workbook/drawing-writer.d.ts

@@ -0,0 +1,2 @@
+import { n as SheetDrawingWrite, r as buildDrawingWritePlan, t as DrawingWritePlan } from "../drawing-writer-Blm_NUSZ.js";
+export { DrawingWritePlan, SheetDrawingWrite, buildDrawingWritePlan };