ppt-codec 1.5.0 → 1.7.0

package/dist/drawing/properties.d.ts

@@ -0,0 +1,29 @@
+import { t as PptRecord } from "../tree-PMcPNgd-.js";
+//#region src/drawing/properties.d.ts
+declare const PROPERTY_ROTATION = 4;
+declare const PROPERTY_PIB = 260;
+declare const PROPERTY_TABLE_PROPERTIES = 927;
+declare const PROPERTY_TABLE_ROW_PROPERTIES = 928;
+declare const PROPERTY_DX_TEXT_LEFT = 129;
+declare const PROPERTY_DY_TEXT_TOP = 130;
+declare const PROPERTY_DX_TEXT_RIGHT = 131;
+declare const PROPERTY_DY_TEXT_BOTTOM = 132;
+declare function degreesToFixedPoint(degrees: number): number;
+declare function fixedPointToDegrees(raw: number): number;
+declare const TABLE_FLAG_IS_TABLE: number;
+declare function readIMsoArray(complex: Uint8Array<ArrayBuffer>): readonly number[];
+declare function writeIMsoArray(elements: readonly number[], elementSize: number): Uint8Array<ArrayBuffer>;
+interface ShapeProperty {
+  readonly value: number;
+  readonly complex: Uint8Array<ArrayBuffer> | undefined;
+}
+declare function readShapeProperties(shape: PptRecord): Map<number, ShapeProperty>;
+interface WritableShapeProperty {
+  readonly opid: number;
+  readonly op: number;
+  readonly fBid?: boolean;
+  readonly complex?: Uint8Array<ArrayBuffer>;
+}
+declare function writeShapePropertyTable(recType: number, entries: readonly WritableShapeProperty[]): Uint8Array<ArrayBuffer>;
+//#endregion
+export { PROPERTY_DX_TEXT_LEFT, PROPERTY_DX_TEXT_RIGHT, PROPERTY_DY_TEXT_BOTTOM, PROPERTY_DY_TEXT_TOP, PROPERTY_PIB, PROPERTY_ROTATION, PROPERTY_TABLE_PROPERTIES, PROPERTY_TABLE_ROW_PROPERTIES, ShapeProperty, TABLE_FLAG_IS_TABLE, WritableShapeProperty, degreesToFixedPoint, fixedPointToDegrees, readIMsoArray, readShapeProperties, writeIMsoArray, writeShapePropertyTable };

package/dist/drawing/properties.js

@@ -0,0 +1,87 @@
+import { PptFormatError } from "../errors.js";
+import { childRecords } from "../record/tree.js";
+import "../record/types.js";
+import { concatBytes, u16le, u32le, writeAtom } from "../record/write.js";
+//#region src/drawing/properties.ts
+const OPID_MASK = 16383;
+const OPID_FCOMPLEX = 16384;
+const OPID_FBID = 32768;
+const PROPERTY_ROTATION = 4;
+const PROPERTY_PIB = 260;
+const PROPERTY_TABLE_PROPERTIES = 927;
+const PROPERTY_TABLE_ROW_PROPERTIES = 928;
+const PROPERTY_DX_TEXT_LEFT = 129;
+const PROPERTY_DY_TEXT_TOP = 130;
+const PROPERTY_DX_TEXT_RIGHT = 131;
+const PROPERTY_DY_TEXT_BOTTOM = 132;
+const FIXED_POINT_ONE = 65536;
+function degreesToFixedPoint(degrees) {
+	return Math.round(degrees * FIXED_POINT_ONE);
+}
+function fixedPointToDegrees(raw) {
+	return raw / FIXED_POINT_ONE;
+}
+const TABLE_FLAG_IS_TABLE = 1;
+function readIMsoArray(complex) {
+	if (complex.length < 6) throw new PptFormatError(`a complex property's IMsoArray carries ${complex.length} bytes, fewer than the 6 its three count fields need`);
+	const view = new DataView(complex.buffer, complex.byteOffset, complex.byteLength);
+	const elementCount = view.getUint16(0, true);
+	const elementSize = view.getUint16(4, true);
+	const data = complex.subarray(6);
+	if (data.length < elementCount * elementSize) throw new PptFormatError(`a complex property's IMsoArray declares ${elementCount} elements of ${elementSize} bytes but only ${data.length} remain`);
+	const elements = [];
+	for (let index = 0; index < elementCount; index += 1) elements.push(view.getInt32(6 + index * elementSize, true));
+	return elements;
+}
+function writeIMsoArray(elements, elementSize) {
+	const data = new Uint8Array(elements.length * elementSize);
+	const view = new DataView(data.buffer);
+	elements.forEach((element, index) => {
+		view.setInt32(index * elementSize, element, true);
+	});
+	return concatBytes(u16le(elements.length), u16le(elements.length), u16le(elementSize), data);
+}
+function readShapeProperties(shape) {
+	const properties = /* @__PURE__ */ new Map();
+	for (const record of childRecords(shape)) {
+		if (record.header.recType !== 61451 && record.header.recType !== 61729 && record.header.recType !== 61730) continue;
+		const count = record.header.recInstance;
+		const needed = count * 6;
+		if (record.data.length < needed) throw new PptFormatError(`a shape property table declares ${count} properties but its ${record.data.length} bytes of data cannot hold the ${needed} its entries need`);
+		const view = new DataView(record.data.buffer, record.data.byteOffset, record.data.byteLength);
+		let complexAt = needed;
+		for (let index = 0; index < count; index += 1) {
+			const at = index * 6;
+			const opid = view.getUint16(at, true);
+			const value = view.getInt32(at + 2, true);
+			const isComplex = (opid & OPID_FCOMPLEX) !== 0;
+			let complex;
+			if (isComplex) {
+				complex = record.data.subarray(complexAt, complexAt + value);
+				complexAt += value;
+				if (complexAt > record.data.length) throw new PptFormatError(`a shape property table's complex data declares ${complexAt} bytes in total but the table carries only ${record.data.length}`);
+			}
+			properties.set(opid & OPID_MASK, {
+				value,
+				complex
+			});
+		}
+	}
+	return properties;
+}
+function writeShapePropertyTable(recType, entries) {
+	const ordered = [...entries].sort((a, b) => a.opid - b.opid);
+	const complexParts = [];
+	const entryParts = ordered.map((entry) => {
+		const isComplex = entry.complex !== void 0;
+		const opidWord = entry.opid | (isComplex ? OPID_FCOMPLEX : 0) | (entry.fBid === true ? OPID_FBID : 0);
+		if (isComplex) complexParts.push(entry.complex);
+		return concatBytes(u16le(opidWord), u32le(entry.op));
+	});
+	return writeAtom(recType, concatBytes(...entryParts, ...complexParts), {
+		recVer: 3,
+		recInstance: ordered.length
+	});
+}
+//#endregion
+export { PROPERTY_DX_TEXT_LEFT, PROPERTY_DX_TEXT_RIGHT, PROPERTY_DY_TEXT_BOTTOM, PROPERTY_DY_TEXT_TOP, PROPERTY_PIB, PROPERTY_ROTATION, PROPERTY_TABLE_PROPERTIES, PROPERTY_TABLE_ROW_PROPERTIES, TABLE_FLAG_IS_TABLE, degreesToFixedPoint, fixedPointToDegrees, readIMsoArray, readShapeProperties, writeIMsoArray, writeShapePropertyTable };

package/dist/drawing/shapes-write.cjs

@@ -1,11 +1,39 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("../errors.cjs");
 const require_record_types = require("../record/types.cjs");
 const require_text_atoms = require("../text/atoms.cjs");
 const require_units = require("../units.cjs");
 const require_content_write = require("../content-write.cjs");
+const require_diagnostics = require("../diagnostics.cjs");
 const require_record_write = require("../record/write.cjs");
+const require_drawing_blips = require("./blips.cjs");
+const require_drawing_properties = require("./properties.cjs");
+const require_read = require("../read.cjs");
 const require_text_style_write = require("../text/style-write.cjs");
 //#region src/drawing/shapes-write.ts
+function insetProperties(shape, isPicture) {
+	const defaultLeftRight = isPicture ? 0 : require_read.DEFAULT_INSET_LEFT_RIGHT_PT;
+	const defaultTopBottom = isPicture ? 0 : require_read.DEFAULT_INSET_TOP_BOTTOM_PT;
+	const entries = [];
+	if (shape.insetLeftPt !== defaultLeftRight) entries.push({
+		opid: 129,
+		op: require_units.pointsToEmu(shape.insetLeftPt)
+	});
+	if (shape.insetTopPt !== defaultTopBottom) entries.push({
+		opid: 130,
+		op: require_units.pointsToEmu(shape.insetTopPt)
+	});
+	if (shape.insetRightPt !== defaultLeftRight) entries.push({
+		opid: 131,
+		op: require_units.pointsToEmu(shape.insetRightPt)
+	});
+	if (shape.insetBottomPt !== defaultTopBottom) entries.push({
+		opid: 132,
+		op: require_units.pointsToEmu(shape.insetBottomPt)
+	});
+	return entries;
+}
+const FSP_CHILD = 2;
 const PATRIARCH_SPID = 1;
 const FIRST_CONTENT_SPID = 2;
 function writeFsp(spid, flags) {
@@ -21,9 +49,23 @@ function writeClientAnchor(xPt, yPt, widthPt, heightPt) {
 function writeTextCharsAtom(text) {
 	return require_record_write.writeAtom(require_record_types.RT_TextCharsAtom, require_record_write.utf16le(text));
 }
-function writeClientTextbox(shape, fontIndexOf) {
-	if (!shape.blocks.some((block) => block.kind === "paragraph")) return;
-	const { text, style } = require_content_write.buildTextBody(shape.blocks, fontIndexOf);
+function writeShapeProperties(shape, pib) {
+	const entries = [];
+	if (shape.rotationDeg !== void 0) entries.push({
+		opid: 4,
+		op: require_drawing_properties.degreesToFixedPoint(shape.rotationDeg)
+	});
+	if (pib !== void 0) entries.push({
+		opid: 260,
+		op: pib,
+		fBid: true
+	});
+	entries.push(...insetProperties(shape, pib !== void 0));
+	return entries.length === 0 ? void 0 : require_drawing_properties.writeShapePropertyTable(require_record_types.OfficeArtFOPT, entries);
+}
+function writeClientTextbox(textBlocks, fontIndexOf) {
+	if (textBlocks.length === 0) return;
+	const { text, style } = require_content_write.buildTextBody(textBlocks, fontIndexOf);
 	const totalParagraphCount = style.paragraphRuns.reduce((sum, run) => sum + run.count, 0);
 	if (totalParagraphCount !== require_text_atoms.characterCountOf(text)) throw new Error(`internal error: built ${totalParagraphCount} characters of paragraph runs for a ${require_text_atoms.characterCountOf(text)}-character text body`);
 	return require_record_write.writeContainer(require_record_types.OfficeArtClientTextbox, [
@@ -32,9 +74,12 @@ function writeClientTextbox(shape, fontIndexOf) {
 		require_text_style_write.writeStyleTextPropAtom(style)
 	]);
 }
-function writeShape(spid, shape, fontIndexOf, clientData) {
-	const clientTextbox = writeClientTextbox(shape, fontIndexOf);
-	const children = [writeFsp(spid, 0), writeClientAnchor(shape.frame.xPt, shape.frame.yPt, shape.frame.widthPt, shape.frame.heightPt)];
+function writeShape(spid, shape, pib, textBlocks, fontIndexOf, clientData) {
+	const properties = writeShapeProperties(shape, pib);
+	const clientTextbox = writeClientTextbox(textBlocks, fontIndexOf);
+	const children = [writeFsp(spid, 0)];
+	if (properties !== void 0) children.push(properties);
+	children.push(writeClientAnchor(shape.frame.xPt, shape.frame.yPt, shape.frame.widthPt, shape.frame.heightPt));
 	if (clientData !== void 0) children.push(clientData);
 	if (clientTextbox !== void 0) children.push(clientTextbox);
 	return require_record_write.writeContainer(require_record_types.OfficeArtSpContainer, children);
@@ -42,19 +87,191 @@ function writeShape(spid, shape, fontIndexOf, clientData) {
 function writePatriarch() {
 	return require_record_write.writeContainer(require_record_types.OfficeArtSpContainer, [require_record_write.writeAtom(require_record_types.OfficeArtFSPGR, /* @__PURE__ */ new Uint8Array(16), { recVer: 1 }), writeFsp(PATRIARCH_SPID, 5)]);
 }
-function writeDrawing(shapes, fontIndexOf) {
-	const shapeContainers = shapes.map((entry, index) => writeShape(FIRST_CONTENT_SPID + index, entry.shape, fontIndexOf, entry.clientData));
-	return require_record_write.writeContainer(require_record_types.RT_Drawing, [require_record_write.writeContainer(require_record_types.OfficeArtDgContainer, [require_record_write.writeContainer(require_record_types.OfficeArtSpgrContainer, [writePatriarch(), ...shapeContainers])])]);
+function reportDrop(context, diagnostic) {
+	context.sink(diagnostic);
+	if (context.strict) throw new require_errors.PptUnsupportedContentError(diagnostic.message);
+}
+function planShapeBlocks(blocks, context, hasOleClientData) {
+	const textBlocks = [];
+	let pib;
+	let table;
+	const drop = (block, reason) => {
+		reportDrop(context, {
+			code: require_diagnostics.PptDiagnosticCodes.BLOCK_DROPPED,
+			severity: "warning",
+			message: `${context.location}: ${reason}`
+		});
+	};
+	for (const block of blocks) {
+		if (block.kind === "embeddedObject" && hasOleClientData) continue;
+		if (block.kind === "paragraph") {
+			textBlocks.push(block);
+			continue;
+		}
+		if (block.kind === "image") {
+			if (!require_drawing_blips.isBlipFormat(block.format)) {
+				reportDrop(context, {
+					code: require_diagnostics.PptDiagnosticCodes.IMAGE_DROPPED,
+					severity: "warning",
+					message: `${context.location}: an image block in format '${block.format}' is dropped; MSOBLIPTYPE gives this writer a blip record for PNG and JPEG only`
+				});
+				continue;
+			}
+			if (pib !== void 0) {
+				reportDrop(context, {
+					code: require_diagnostics.PptDiagnosticCodes.IMAGE_DROPPED,
+					severity: "warning",
+					message: `${context.location}: a second image block is dropped; a shape carries exactly one blip-store reference, and an earlier image already consumed it`
+				});
+				continue;
+			}
+			pib = context.blipIndexOf(block);
+			continue;
+		}
+		if (block.kind === "table") {
+			if (table !== void 0) {
+				drop(block, "a second 'table' block is dropped; a shape becomes one table group, and an earlier table already did");
+				continue;
+			}
+			table = block;
+			continue;
+		}
+		drop(block, `a '${block.kind}' block is dropped; this writer produces no [MS-PPT] spelling for it`);
+	}
+	if (table !== void 0) {
+		for (const block of textBlocks) drop(block, "a 'paragraph' block is dropped; a shape carrying a table becomes a table group, which holds its text in cells rather than a text body of its own");
+		if (pib !== void 0) reportDrop(context, {
+			code: require_diagnostics.PptDiagnosticCodes.IMAGE_DROPPED,
+			severity: "warning",
+			message: `${context.location}: an image block is dropped; a shape carrying a table becomes a table group, which has no blip reference of its own`
+		});
+		return {
+			pib: void 0,
+			textBlocks: [],
+			table
+		};
+	}
+	return {
+		pib,
+		textBlocks,
+		table
+	};
+}
+function tableRowHeights(table, frameHeightMasterUnits) {
+	const stated = table.rows.map((row) => row.heightPt === void 0 ? void 0 : require_units.pointsToMasterUnits(row.heightPt));
+	const unstatedCount = stated.filter((height) => height === void 0).length;
+	if (unstatedCount === 0) return stated.map((height) => {
+		if (height === void 0) throw new Error("internal error: a stated row height became unstated in the same pass");
+		return height;
+	});
+	const remaining = frameHeightMasterUnits - stated.reduce((sum, height) => sum + (height ?? 0), 0);
+	const shared = Math.max(1, Math.round(remaining / unstatedCount));
+	return stated.map((height) => height ?? shared);
+}
+function writeTableGroup(spid, shape, table, context) {
+	const { frame } = shape;
+	const rowHeights = tableRowHeights(table, require_units.pointsToMasterUnits(frame.heightPt));
+	const declaredWidths = table.columnWidthsPt.map(require_units.pointsToMasterUnits);
+	const cellCount = Math.max(1, ...table.rows.map((row) => row.cells.length), declaredWidths.length);
+	const lastDeclared = declaredWidths.at(-1);
+	const equalShare = Math.max(1, Math.round(require_units.pointsToMasterUnits(frame.widthPt) / cellCount));
+	const columnWidthsMasterUnits = Array.from({ length: cellCount }, (_, index) => declaredWidths[index] ?? lastDeclared ?? equalShare);
+	const columnBoundaries = [];
+	let columnEdge = require_units.pointsToMasterUnits(frame.xPt);
+	for (const width of columnWidthsMasterUnits) {
+		columnBoundaries.push(columnEdge);
+		columnEdge += width;
+	}
+	columnBoundaries.push(columnEdge);
+	const rowBoundaries = [];
+	let rowEdge = require_units.pointsToMasterUnits(frame.yPt);
+	for (const height of rowHeights) {
+		rowBoundaries.push(rowEdge);
+		rowEdge += height;
+	}
+	rowBoundaries.push(rowEdge);
+	const rowHeightsPayload = require_drawing_properties.writeIMsoArray(rowHeights, 4);
+	const tableLeft = require_units.pointsToMasterUnits(frame.xPt);
+	const tableTop = require_units.pointsToMasterUnits(frame.yPt);
+	const tableRight = require_units.pointsToMasterUnits(frame.xPt + frame.widthPt);
+	const tableBottom = require_units.pointsToMasterUnits(frame.yPt + frame.heightPt);
+	const groupShape = require_record_write.writeContainer(require_record_types.OfficeArtSpContainer, [
+		require_record_write.writeAtom(require_record_types.OfficeArtFSPGR, require_record_write.concatBytes(require_record_write.i32le(tableLeft), require_record_write.i32le(tableTop), require_record_write.i32le(tableRight), require_record_write.i32le(tableBottom)), { recVer: 1 }),
+		writeFsp(spid, 513),
+		...shape.rotationDeg === void 0 ? [] : [require_drawing_properties.writeShapePropertyTable(require_record_types.OfficeArtFOPT, [{
+			opid: 4,
+			op: require_drawing_properties.degreesToFixedPoint(shape.rotationDeg)
+		}])],
+		require_drawing_properties.writeShapePropertyTable(require_record_types.OfficeArtTertiaryFOPT, [{
+			opid: 927,
+			op: 1
+		}, {
+			opid: 928,
+			op: rowHeightsPayload.length,
+			fBid: true,
+			complex: rowHeightsPayload
+		}]),
+		writeClientAnchor(frame.xPt, frame.yPt, frame.widthPt, frame.heightPt)
+	]);
+	let cellSpid = spid + 1;
+	const cellShapes = table.rows.flatMap((row, rowIndex) => row.cells.map((cell, columnIndex) => {
+		const cellLeft = columnBoundaries[columnIndex];
+		const cellRight = columnBoundaries[columnIndex + 1];
+		const cellTop = rowBoundaries[rowIndex];
+		const cellBottom = rowBoundaries[rowIndex + 1];
+		if (cellLeft === void 0 || cellRight === void 0 || cellTop === void 0 || cellBottom === void 0) throw new Error("internal error: a table cell sits outside the grid boundaries derived from its own table");
+		if (cell.colSpan !== void 0 && cell.colSpan > 1) context.sink({
+			code: require_diagnostics.PptDiagnosticCodes.TABLE_SPAN_DROPPED,
+			severity: "warning",
+			message: `${context.location}: a table cell's colSpan ${String(cell.colSpan)} is dropped; a PowerPoint 97-2003 table is a strict grid of shapes with no merge records, so the cell is written one column wide`
+		});
+		if (cell.rowSpan !== void 0 && cell.rowSpan > 1) context.sink({
+			code: require_diagnostics.PptDiagnosticCodes.TABLE_SPAN_DROPPED,
+			severity: "warning",
+			message: `${context.location}: a table cell's rowSpan ${String(cell.rowSpan)} is dropped; a PowerPoint 97-2003 table is a strict grid of shapes with no merge records, so the cell is written one row tall`
+		});
+		const paragraphs = cell.blocks.filter((block) => block.kind === "paragraph");
+		for (const block of cell.blocks) if (block.kind !== "paragraph") reportDrop(context, {
+			code: require_diagnostics.PptDiagnosticCodes.BLOCK_DROPPED,
+			severity: "warning",
+			message: `${context.location}: a '${block.kind}' block inside a table cell is dropped; a table cell in this format is a plain text-box shape with no property table or object reference of its own`
+		});
+		const textbox = writeClientTextbox(paragraphs, context.fontIndexOf);
+		const children = [writeFsp(cellSpid, FSP_CHILD), require_record_write.writeAtom(require_record_types.OfficeArtChildAnchor, require_record_write.concatBytes(require_record_write.i32le(cellLeft), require_record_write.i32le(cellTop), require_record_write.i32le(cellRight), require_record_write.i32le(cellBottom)))];
+		cellSpid += 1;
+		if (textbox !== void 0) children.push(textbox);
+		return require_record_write.writeContainer(require_record_types.OfficeArtSpContainer, children);
+	}));
+	return {
+		bytes: require_record_write.writeContainer(require_record_types.OfficeArtSpgrContainer, [groupShape, ...cellShapes]),
+		shapeCount: 1 + table.rows.reduce((sum, row) => sum + row.cells.length, 0)
+	};
 }
-function writeSlideDrawing(shapes, fontIndexOf) {
-	return writeDrawing(shapes.map((shape) => ({
-		shape,
-		clientData: void 0
-	})), fontIndexOf);
+function writeDrawing(shapes, context) {
+	let nextSpid = FIRST_CONTENT_SPID;
+	let shapeCount = 1;
+	const shapeContainers = [];
+	for (const entry of shapes) {
+		const plan = planShapeBlocks(entry.shape.blocks, context, entry.clientData !== void 0);
+		if (plan.table !== void 0) {
+			const group = writeTableGroup(nextSpid, entry.shape, plan.table, context);
+			nextSpid += group.shapeCount;
+			shapeCount += group.shapeCount;
+			shapeContainers.push(group.bytes);
+			continue;
+		}
+		shapeContainers.push(writeShape(nextSpid, entry.shape, plan.pib, plan.textBlocks, context.fontIndexOf, entry.clientData));
+		nextSpid += 1;
+		shapeCount += 1;
+	}
+	return {
+		bytes: require_record_write.writeContainer(require_record_types.RT_Drawing, [require_record_write.writeContainer(require_record_types.OfficeArtDgContainer, [require_record_write.writeContainer(require_record_types.OfficeArtSpgrContainer, [writePatriarch(), ...shapeContainers])])]),
+		shapeCount,
+		maxSpid: Math.max(PATRIARCH_SPID, nextSpid - 1)
+	};
 }
-function writeDrawingWithClientData(shapes, fontIndexOf) {
-	return writeDrawing(shapes, fontIndexOf);
+function writeSlideDrawing(shapes, context) {
+	return writeDrawing(shapes, context);
 }
 //#endregion
-exports.writeDrawingWithClientData = writeDrawingWithClientData;
 exports.writeSlideDrawing = writeSlideDrawing;

package/dist/drawing/shapes-write.d.cts

@@ -1,10 +1,22 @@
-import { ContentShape } from "document-schema.js";
+import { a as PptDiagnosticSink } from "../diagnostics-CqxAnubw.cjs";
+import { ContentImageBlock, ContentShape } from "document-schema.js";
 //#region src/drawing/shapes-write.d.ts
 interface DrawingShape {
   readonly shape: ContentShape;
   readonly clientData: Uint8Array<ArrayBuffer> | undefined;
 }
-declare function writeSlideDrawing(shapes: readonly ContentShape[], fontIndexOf: (family: string) => number): Uint8Array<ArrayBuffer>;
-declare function writeDrawingWithClientData(shapes: readonly DrawingShape[], fontIndexOf: (family: string) => number): Uint8Array<ArrayBuffer>;
+interface DrawingWritten {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly shapeCount: number;
+  readonly maxSpid: number;
+}
+interface DrawingWriteContext {
+  readonly fontIndexOf: (family: string) => number;
+  readonly blipIndexOf: (image: ContentImageBlock) => number;
+  readonly sink: PptDiagnosticSink;
+  readonly strict: boolean;
+  readonly location: string;
+}
+declare function writeSlideDrawing(shapes: readonly DrawingShape[], context: DrawingWriteContext): DrawingWritten;
 //#endregion
-export { DrawingShape, writeDrawingWithClientData, writeSlideDrawing };
+export { DrawingShape, DrawingWriteContext, DrawingWritten, writeSlideDrawing };

package/dist/drawing/shapes-write.d.ts

@@ -1,10 +1,22 @@
-import { ContentShape } from "document-schema.js";
+import { a as PptDiagnosticSink } from "../diagnostics-CqxAnubw.js";
+import { ContentImageBlock, ContentShape } from "document-schema.js";
 //#region src/drawing/shapes-write.d.ts
 interface DrawingShape {
   readonly shape: ContentShape;
   readonly clientData: Uint8Array<ArrayBuffer> | undefined;
 }
-declare function writeSlideDrawing(shapes: readonly ContentShape[], fontIndexOf: (family: string) => number): Uint8Array<ArrayBuffer>;
-declare function writeDrawingWithClientData(shapes: readonly DrawingShape[], fontIndexOf: (family: string) => number): Uint8Array<ArrayBuffer>;
+interface DrawingWritten {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly shapeCount: number;
+  readonly maxSpid: number;
+}
+interface DrawingWriteContext {
+  readonly fontIndexOf: (family: string) => number;
+  readonly blipIndexOf: (image: ContentImageBlock) => number;
+  readonly sink: PptDiagnosticSink;
+  readonly strict: boolean;
+  readonly location: string;
+}
+declare function writeSlideDrawing(shapes: readonly DrawingShape[], context: DrawingWriteContext): DrawingWritten;
 //#endregion
-export { DrawingShape, writeDrawingWithClientData, writeSlideDrawing };
+export { DrawingShape, DrawingWriteContext, DrawingWritten, writeSlideDrawing };