reamkit 1.13.0 → 1.15.0

package/dist/esm/excel/xlsx-reader.js

@@ -8,6 +8,7 @@ import { isOoxmlRel } from "../core/opc/relationship-types.js";
 import { OpcPackage } from "../core/opc/package.js";
 import { parseCoreProperties } from "../core/opc/core-properties.js";
 import "../core/opc/index.js";
+import { parseAreaRef } from "./defined-name-ref.js";
 import { parseSharedStrings } from "./shared-strings-parser.js";
 import { parseWorkbook } from "./workbook-parser.js";
 import { parseWorksheet } from "./worksheet-parser.js";
@@ -18,6 +19,10 @@ import { parseSheetDrawing } from "./sheet-drawing.js";
 import { parseTablePartFull } from "./table-parser.js";
 import { parsePivotTablePart } from "./pivot-table-parser.js";
 import { parseSlicerCachePart, parseSlicerPart } from "./slicer-parser.js";
+import { parseLegacyComments, parsePersons, parseThreadedComments } from "./comments-parser.js";
+import { parseFormControlProps } from "./form-control-parser.js";
+import { activeXBinRelId, activeXType, parseActiveX, parseActiveXBin } from "./activex-parser.js";
+import { parseSheetShapes } from "./sheet-shape-parser.js";
 import { projectSheetDoc } from "./sheet-to-flow.js";
 //#region src/excel/xlsx-reader.ts
 var WORKBOOK_PART = "xl/workbook.xml";
@@ -26,10 +31,12 @@ var STYLES_PART = "xl/styles.xml";
 var CORE_PROPS_PART = "docProps/core.xml";
 var SLICER_REL_TAIL = "/slicer";
 var SLICER_CACHE_REL_TAIL = "/slicerCache";
+var THREADED_COMMENTS_REL_TAIL = "/threadedComment";
+var PERSON_REL_TAIL = "/person";
 var MAX_SLICER_ITEMS = 256;
-function readXlsx(xlsx) {
+function readXlsx(xlsx, options = {}) {
 	return {
-		doc: projectSheetDoc(readXlsxToSheetDoc(xlsx)),
+		doc: projectSheetDoc(readXlsxToSheetDoc(xlsx), options),
 		losses: []
 	};
 }
@@ -40,11 +47,21 @@ function readXlsxToSheetDoc(xlsx) {
 	const { sheets, date1904, definedNames } = parseWorkbook(workbookData);
 	if (sheets.length === 0) throw new Error("xlsx has no sheets");
 	const sharedStringsData = pkg.getPart(SHARED_STRINGS_PART);
-	const sharedStrings = sharedStringsData ? parseSharedStrings(sharedStringsData) : [];
+	const { texts: sharedStrings, runs: sharedStringRuns } = sharedStringsData ? parseSharedStrings(sharedStringsData) : {
+		texts: [],
+		runs: []
+	};
 	const stylesData = pkg.getPart(STYLES_PART);
 	const styles = stylesData ? parseXlsxStyles(stylesData) : EMPTY_XLSX_STYLES;
 	const workbookRels = pkg.getPartRelationships(WORKBOOK_PART);
+	const persons = /* @__PURE__ */ new Map();
+	for (const rel of workbookRels) {
+		if (!rel.type.endsWith(PERSON_REL_TAIL)) continue;
+		const part = pkg.resolveRelatedPart(WORKBOOK_PART, rel);
+		if (part) for (const [id, name] of parsePersons(part.data)) persons.set(id, name);
+	}
 	const chartData = /* @__PURE__ */ new Map();
+	const resources = new ResourceStore();
 	const palette = buildThemePalette(pkg, workbookRels);
 	const resolveColor = makeColorResolver(palette);
 	const sheetsOut = [];
@@ -58,21 +75,39 @@ function readXlsxToSheetDoc(xlsx) {
 		if (!resolved) continue;
 		const worksheet = parseWorksheet(resolved.data);
 		const charts = [];
+		const images = [];
+		let shapes;
 		if (worksheet.drawingRelId) {
 			const drawingRel = pkg.getPartRelationships(resolved.path).find((r) => r.id === worksheet.drawingRelId);
 			const drawing = drawingRel ? pkg.resolveRelatedPart(resolved.path, drawingRel) : void 0;
-			if (drawing) for (const ref of parseSheetDrawing(drawing.data, drawing.path, pkg, worksheet)) {
-				if (!chartData.has(ref.chartPartPath)) {
-					const chartXml = pkg.getPart(ref.chartPartPath);
-					const parsed = chartXml ? parseChart(chartXml, resolveColor) : null;
-					if (!parsed) continue;
-					chartData.set(ref.chartPartPath, withChartColorStyle(parsed, pkg, ref.chartPartPath, resolveColor));
+			if (drawing) {
+				const { charts: chartRefs, pictures } = parseSheetDrawing(drawing.data, drawing.path, pkg, worksheet);
+				for (const ref of chartRefs) {
+					if (!chartData.has(ref.chartPartPath)) {
+						const chartXml = pkg.getPart(ref.chartPartPath);
+						const parsed = chartXml ? parseChart(chartXml, resolveColor) : null;
+						if (!parsed) continue;
+						chartData.set(ref.chartPartPath, withChartColorStyle(parsed, pkg, ref.chartPartPath, resolveColor));
+					}
+					charts.push({
+						chartPartPath: ref.chartPartPath,
+						widthPt: ref.widthPt,
+						heightPt: ref.heightPt
+					});
+				}
+				for (const pic of pictures) {
+					const bytes = pkg.getPart(pic.imagePartPath);
+					if (!bytes) continue;
+					images.push({
+						resourceId: resources.put(bytes),
+						widthPt: pic.widthPt,
+						heightPt: pic.heightPt
+					});
+				}
+				if (bytesInclude(drawing.data, ":sp>") || bytesInclude(drawing.data, ":sp ")) {
+					const parsed = parseSheetShapes(drawing.data, worksheet, resolveColor);
+					if (parsed.length > 0) shapes = parsed;
 				}
-				charts.push({
-					chartPartPath: ref.chartPartPath,
-					widthPt: ref.widthPt,
-					heightPt: ref.heightPt
-				});
 			}
 		}
 		let tables;
@@ -118,6 +153,82 @@ function readXlsxToSheetDoc(xlsx) {
 			}
 			if (resolvedPivots.length > 0) pivotTables = resolvedPivots;
 		}
+		let hyperlinks;
+		if (worksheet.hyperlinks && worksheet.hyperlinks.length > 0) {
+			const wsRels = pkg.getPartRelationships(resolved.path);
+			const resolvedLinks = [];
+			for (const h of worksheet.hyperlinks) {
+				if (h.relId === void 0) continue;
+				const rel = wsRels.find((r) => r.id === h.relId);
+				if (!rel || rel.targetMode !== "External" || !rel.target) continue;
+				const area = parseAreaRef(h.ref);
+				if (!area) continue;
+				resolvedLinks.push({
+					ref: {
+						startColumn: area.startColumn,
+						startRow: area.startRow,
+						endColumn: area.endColumn,
+						endRow: area.endRow
+					},
+					url: rel.target
+				});
+			}
+			if (resolvedLinks.length > 0) hyperlinks = resolvedLinks;
+		}
+		let comments;
+		{
+			const wsRels = pkg.getPartRelationships(resolved.path);
+			const resolvedComments = [];
+			for (const rel of wsRels) {
+				if (!isOoxmlRel(rel.type, "comments")) continue;
+				const part = pkg.resolveRelatedPart(resolved.path, rel);
+				if (part) resolvedComments.push(...parseLegacyComments(part.data));
+			}
+			for (const rel of wsRels) {
+				if (!rel.type.endsWith(THREADED_COMMENTS_REL_TAIL)) continue;
+				const part = pkg.resolveRelatedPart(resolved.path, rel);
+				if (part) resolvedComments.push(...parseThreadedComments(part.data, persons));
+			}
+			if (resolvedComments.length > 0) comments = resolvedComments;
+		}
+		let formControls;
+		if (worksheet.formControls && worksheet.formControls.length > 0) {
+			const wsRels = pkg.getPartRelationships(resolved.path);
+			const resolvedControls = [];
+			for (const fc of worksheet.formControls) {
+				const rel = wsRels.find((r) => r.id === fc.relId);
+				const part = rel ? pkg.resolveRelatedPart(resolved.path, rel) : void 0;
+				const props = part ? parseFormControlProps(part.data) : {};
+				resolvedControls.push({
+					...fc.name ? { name: fc.name } : {},
+					...props
+				});
+			}
+			if (resolvedControls.length > 0) formControls = resolvedControls;
+		}
+		let activeXControls;
+		if (worksheet.oleObjects && worksheet.oleObjects.length > 0) {
+			const wsRels = pkg.getPartRelationships(resolved.path);
+			const resolvedAx = [];
+			for (const ole of worksheet.oleObjects) {
+				const rel = wsRels.find((r) => r.id === ole.relId);
+				const part = rel ? pkg.resolveRelatedPart(resolved.path, rel) : void 0;
+				const props = part ? parseActiveX(part.data) : {};
+				let binProps = {};
+				if (part) {
+					const binRelId = activeXBinRelId(part.data);
+					const binRel = binRelId ? pkg.getPartRelationships(part.path).find((r) => r.id === binRelId) : void 0;
+					const binPart = binRel ? pkg.resolveRelatedPart(part.path, binRel) : void 0;
+					if (binPart) binProps = parseActiveXBin(binPart.data);
+				}
+				resolvedAx.push({
+					type: activeXType(ole.progId),
+					...binProps,
+					...props
+				});
+			}
+			if (resolvedAx.length > 0) activeXControls = resolvedAx;
+		}
 		const grid = tables || pivotTables ? {
 			...worksheet,
 			...tables ? { tables } : {},
@@ -126,7 +237,13 @@ function readXlsxToSheetDoc(xlsx) {
 		sheetsOut.push({
 			name: sheet.name,
 			grid,
-			...charts.length > 0 ? { charts } : {}
+			...charts.length > 0 ? { charts } : {},
+			...images.length > 0 ? { images } : {},
+			...shapes ? { shapes } : {},
+			...hyperlinks ? { hyperlinks } : {},
+			...comments ? { comments } : {},
+			...formControls ? { formControls } : {},
+			...activeXControls ? { activeXControls } : {}
 		});
 	}
 	if (pendingSlicers.length > 0) {
@@ -154,10 +271,11 @@ function readXlsxToSheetDoc(xlsx) {
 		sheets: sheetsOut,
 		styles,
 		sharedStrings,
+		...sharedStringRuns.some((r) => r !== void 0) ? { sharedStringRuns } : {},
 		definedNames,
 		date1904,
 		...chartData.size > 0 ? { chartData } : {},
-		resources: new ResourceStore(),
+		resources,
 		...info ? { info } : {}
 	};
 }

package/dist/esm/excel/xlsx-to-pdf.d.ts

@@ -7,6 +7,7 @@ export interface ConvertXlsxOptions extends Omit<StyledRenderOptions, 'registry'
     readonly fontFamily?: string;
     readonly fontFetch?: FetchLike;
     readonly embedSource?: boolean;
+    readonly now?: Date;
     readonly signature?: SignatureOptions;
 }
 /**

package/dist/esm/excel/xlsx-to-pdf.js

@@ -45,8 +45,8 @@ function prepareXlsxStyledRender(xlsx, options) {
 	const fonts = options.fonts ?? (options.fontBytes ? { regular: options.fontBytes } : void 0);
 	if (!fonts) throw new Error("convertXlsxToPdfSync requires options.fonts or options.fontBytes");
 	const registry = FontRegistry.fromBytes(fonts);
-	const { doc: flow } = readXlsx(xlsx);
-	const { fontBytes: _ignoreA, fonts: _ignoreB, section: sectionOverride, info: callerInfo, embedSource, attachments: callerAttachments, signature: _ignoreSig, layoutProfile: _ignoreProfile, ...renderOptions } = options;
+	const { doc: flow } = readXlsx(xlsx, options.now !== void 0 ? { now: options.now } : {});
+	const { fontBytes: _ignoreA, fonts: _ignoreB, section: sectionOverride, info: callerInfo, embedSource, now: _ignoreNow, attachments: callerAttachments, signature: _ignoreSig, layoutProfile: _ignoreProfile, ...renderOptions } = options;
 	const section = sectionOverride ?? flow.section;
 	const info = flow.info || callerInfo ? {
 		...flow.info,

package/dist/esm/excel/xlsx-writer.js

@@ -230,6 +230,16 @@ function cfRuleXml(rule) {
 		case "colorScale": return `<cfRule type="colorScale"${p}><colorScale>` + rule.cfvos.map(cfvoXml).join("") + rule.colorsHex.map((c) => `<color rgb="FF${c}"/>`).join("") + "</colorScale></cfRule>";
 		case "dataBar": return `<cfRule type="dataBar"${p}><dataBar` + (rule.minLength !== void 0 ? ` minLength="${rule.minLength}"` : "") + (rule.maxLength !== void 0 ? ` maxLength="${rule.maxLength}"` : "") + ">" + rule.cfvos.map(cfvoXml).join("") + `<color rgb="FF${rule.colorHex}"/></dataBar></cfRule>`;
 		case "iconSet": return `<cfRule type="iconSet"${p}><iconSet iconSet="${rule.iconSet}"` + (rule.reverse ? " reverse=\"1\"" : "") + ">" + rule.cfvos.map(cfvoXml).join("") + "</iconSet></cfRule>";
+		case "top10": return `<cfRule type="top10"${p} dxfId="${rule.dxfId}" rank="${rule.rank}"` + (rule.percent ? " percent=\"1\"" : "") + (rule.bottom ? " bottom=\"1\"" : "") + "/>";
+		case "aboveAverage": return `<cfRule type="aboveAverage"${p} dxfId="${rule.dxfId}"` + (rule.aboveAverage ? "" : " aboveAverage=\"0\"") + (rule.equalAverage ? " equalAverage=\"1\"" : "") + (rule.stdDev !== void 0 ? ` stdDev="${rule.stdDev}"` : "") + "/>";
+		case "duplicateValues":
+		case "uniqueValues": return `<cfRule type="${rule.type}"${p} dxfId="${rule.dxfId}"/>`;
+		case "containsText":
+		case "notContainsText":
+		case "beginsWith":
+		case "endsWith": return `<cfRule type="${rule.type}"${p} operator="${rule.type}" dxfId="${rule.dxfId}" text="${escapeAttr(rule.text)}">` + (rule.formula !== void 0 ? `<formula>${escapeText(rule.formula)}</formula>` : "") + "</cfRule>";
+		case "expression": return `<cfRule type="expression"${p} dxfId="${rule.dxfId}"><formula>${escapeText(rule.formula)}</formula></cfRule>`;
+		case "timePeriod": return `<cfRule type="timePeriod"${p} timePeriod="${rule.timePeriod}" dxfId="${rule.dxfId}">` + (rule.formula !== void 0 ? `<formula>${escapeText(rule.formula)}</formula>` : "") + "</cfRule>";
 	}
 }
 function cfvoXml(cfvo) {
@@ -313,7 +323,7 @@ function patternFill(f) {
 	return `<patternFill${f.patternType ? ` patternType="${f.patternType}"` : ""}>${inner}</patternFill>`;
 }
 function borderXml(b) {
-	return `<border>${edgeXml("left", b.left)}${edgeXml("right", b.right)}${edgeXml("top", b.top)}${edgeXml("bottom", b.bottom)}</border>`;
+	return `<border${b.diagonal ? `${b.diagonalUp ? " diagonalUp=\"1\"" : ""}${b.diagonalDown ? " diagonalDown=\"1\"" : ""}` : ""}>${edgeXml("left", b.left)}${edgeXml("right", b.right)}${edgeXml("top", b.top)}${edgeXml("bottom", b.bottom)}${edgeXml("diagonal", b.diagonal)}</border>`;
 }
 function edgeXml(name, edge) {
 	if (!edge || !edge.style) return `<${name}/>`;
@@ -323,7 +333,7 @@ function edgeXml(name, edge) {
 function cellXfXml(xf) {
 	const apply = applyAttr("applyNumberFormat", xf.applyNumberFormat) + applyAttr("applyFont", xf.applyFont) + applyAttr("applyFill", xf.applyFill) + applyAttr("applyBorder", xf.applyBorder) + applyAttr("applyAlignment", xf.applyAlignment);
 	const a = xf.alignment;
-	const alignment = a ? `<alignment${a.horizontal ? ` horizontal="${a.horizontal}"` : ""}${a.vertical ? ` vertical="${a.vertical}"` : ""}${a.wrapText ? " wrapText=\"1\"" : ""}/>` : "";
+	const alignment = a ? `<alignment${a.horizontal ? ` horizontal="${a.horizontal}"` : ""}${a.vertical ? ` vertical="${a.vertical}"` : ""}${a.wrapText ? " wrapText=\"1\"" : ""}${a.textRotation !== void 0 ? ` textRotation="${a.textRotation}"` : ""}${a.indent !== void 0 ? ` indent="${a.indent}"` : ""}${a.shrinkToFit ? " shrinkToFit=\"1\"" : ""}/>` : "";
 	return `<xf numFmtId="${xf.numFmtId}" fontId="${xf.fontId}" fillId="${xf.fillId}" borderId="${xf.borderId}"${apply}>` + alignment + "</xf>";
 }
 function applyAttr(name, value) {

package/dist/esm/layout/styled-layout.js

@@ -2430,6 +2430,35 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 			}
 		}
 		emitCellBorders(out, cell, cellX, rowBottom, row.heightPt, pageHeight, row.rowIdx, row.rowCount, colCount);
+		const diagDown = cell.borders.diagonalDown;
+		const diagUp = cell.borders.diagonalUp;
+		if ((diagDown || diagUp) && cell.mergeRole !== "middle" && cell.mergeRole !== "end") {
+			const transform = flipTransform([
+				1,
+				0,
+				0,
+				1,
+				cellX,
+				rowBottom
+			], pageHeight);
+			const w = cell.widthPt;
+			const h = row.heightPt;
+			const pushDiagonal = (b, y0, y1) => {
+				out.push({
+					type: "shape",
+					shape: {
+						paths: [new PathBuilder().moveTo(0, y0).lineTo(w, y1).build()],
+						stroke: {
+							colorHex: b.colorHex ?? "000000",
+							widthPt: b.width ?? .75
+						},
+						transform
+					}
+				});
+			};
+			if (diagDown) pushDiagonal(diagDown, h, 0);
+			if (diagUp) pushDiagonal(diagUp, 0, h);
+		}
 		if (cell.mergeRole === "middle" || cell.mergeRole === "end") continue;
 		let textY = rowTop - cell.padTopPt;
 		for (const line of cell.lines) {

package/dist/esm/pptx/ppt/ppt-reader.d.ts

@@ -0,0 +1,4 @@
+import { DocumentReader, ReadResult } from '../../core/ir/adapters.js';
+import { FlowDoc } from '../../core/ir/flow.js';
+export declare function readPpt(bytes: Uint8Array): ReadResult<FlowDoc>;
+export declare const pptReader: DocumentReader<FlowDoc>;

package/dist/esm/pptx/ppt/ppt-reader.js

@@ -0,0 +1,337 @@
+import { pt } from "../../core/ir/units.js";
+import { ResourceStore } from "../../core/ir/resources.js";
+import { FEATURES } from "../../core/ir/features.js";
+import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../../core/style-cascade/resolver.js";
+import "../../core/style-cascade/index.js";
+import { isCfb, openCfb } from "../../core/ole/cfb.js";
+import { extractPptContent, paragraphText } from "./ppt-text.js";
+//#region src/pptx/ppt/ppt-reader.ts
+var ZERO_WIDTH_SPACE = "​";
+var DEFAULT_SLIDE_W = 720;
+var DEFAULT_SLIDE_H = 540;
+var SLIDE_MARGIN = 36;
+var LEVEL_INDENT_PT = 18;
+function looksLikePpt(bytes) {
+	if (!isCfb(bytes)) return false;
+	try {
+		return openCfb(bytes).hasStream("PowerPoint Document");
+	} catch {
+		return false;
+	}
+}
+var PPT_TEXT_LOSS = {
+	severity: "degraded",
+	feature: FEATURES.text,
+	detail: "legacy .ppt: each slide's text (with run formatting — bold/italic/underline/size/colour — and paragraph alignment/indent), embedded images, per-shape placement and decorative autoshapes (preset or exact freeform geometry with literal, scheme- or system-resolved fill/line colours) are read into one page per slide (re-save as .pptx for full fidelity)"
+};
+var PPT_ENCRYPTED_LOSS = {
+	severity: "dropped",
+	feature: FEATURES.text,
+	detail: "legacy .ppt is encrypted/obfuscated — its text cannot be read"
+};
+function readPpt(bytes) {
+	const content = extractPptContent(bytes);
+	const width = pt(content.slideWidthPt ?? DEFAULT_SLIDE_W);
+	const height = pt(content.slideHeightPt ?? DEFAULT_SLIDE_H);
+	const resources = new ResourceStore();
+	return {
+		doc: {
+			kind: "flow",
+			body: resolveBodyStyles(buildBody(content, resources), EMPTY_STYLE_SHEET),
+			sections: [],
+			section: {
+				pageSize: {
+					width,
+					height
+				},
+				margins: {
+					top: pt(SLIDE_MARGIN),
+					right: pt(SLIDE_MARGIN),
+					bottom: pt(SLIDE_MARGIN),
+					left: pt(SLIDE_MARGIN)
+				},
+				headers: [],
+				footers: []
+			},
+			styles: EMPTY_STYLE_SHEET,
+			resources
+		},
+		losses: [content.encrypted ? PPT_ENCRYPTED_LOSS : PPT_TEXT_LOSS]
+	};
+}
+function buildBody(content, resources) {
+	const body = [];
+	content.slides.forEach((slide, slideIndex) => {
+		const inFlowParas = [];
+		const inFlowImages = [];
+		const floats = [];
+		for (const shape of slide.shapes) if (shape.rectPt) {
+			if (shape.paragraphs?.some((p) => paragraphText(p).length > 0)) floats.push(positionedTextShape(shape.rectPt, shape.paragraphs));
+			if (shape.image) {
+				const block = positionedImage(shape.rectPt, shape.image, resources);
+				if (block) floats.push(block);
+			}
+			if (shape.autoShape) floats.push(positionedAutoShape(shape.rectPt, shape.autoShape));
+		} else {
+			for (const para of shape.paragraphs ?? []) if (paragraphText(para).length > 0) inFlowParas.push(flowParagraph(para));
+			if (shape.image) {
+				const block = inFlowImage(shape.image, resources);
+				if (block) inFlowImages.push(block);
+			}
+		}
+		pushSlide(body, [...inFlowParas, ...inFlowImages], floats, slideIndex > 0);
+	});
+	if (body.length === 0) body.push(anchorParagraph(false));
+	return body;
+}
+function pushSlide(body, inFlow, floats, breakBefore) {
+	if (inFlow.length === 0 && floats.length === 0) {
+		body.push(anchorParagraph(breakBefore));
+		return;
+	}
+	if (inFlow.length > 0) {
+		const first = inFlow[0];
+		if (breakBefore && first.kind === "paragraph") inFlow[0] = {
+			kind: "paragraph",
+			paragraph: {
+				...first.paragraph,
+				properties: {
+					...first.paragraph.properties,
+					pageBreakBefore: true
+				}
+			}
+		};
+		else if (breakBefore) body.push(anchorParagraph(true));
+		body.push(...inFlow);
+	} else body.push(anchorParagraph(breakBefore));
+	body.push(...floats);
+}
+function flowParagraph(para) {
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: toParaProperties(para, false),
+			runs: para.runs.map(toRun)
+		}
+	};
+}
+function floatAt(rect) {
+	return {
+		wrap: "none",
+		posH: {
+			relativeFrom: "page",
+			offsetPt: pt(rect.x)
+		},
+		posV: {
+			relativeFrom: "page",
+			offsetPt: pt(rect.y)
+		}
+	};
+}
+function positionedTextShape(rect, paragraphs) {
+	return {
+		kind: "shape",
+		shape: {
+			float: floatAt(rect),
+			width: pt(rect.w),
+			height: pt(rect.h),
+			geometry: {
+				kind: "preset",
+				preset: "rect",
+				adjust: /* @__PURE__ */ new Map()
+			},
+			fill: { kind: "none" },
+			text: {
+				content: paragraphs.filter((p) => paragraphText(p).length > 0).map(flowParagraph),
+				anchor: "t"
+			},
+			paragraphProperties: {}
+		}
+	};
+}
+function positionedImage(rect, image, resources) {
+	if (!imagePixelSize(image.bytes)) return void 0;
+	return {
+		kind: "image",
+		image: {
+			float: floatAt(rect),
+			resource: resources.put(image.bytes),
+			width: pt(rect.w),
+			height: pt(rect.h),
+			paragraphProperties: {}
+		}
+	};
+}
+var SHAPE_PRESETS = new Map([
+	[1, "rect"],
+	[2, "roundRect"],
+	[3, "ellipse"],
+	[4, "diamond"],
+	[5, "triangle"],
+	[6, "rtTriangle"],
+	[7, "parallelogram"],
+	[8, "trapezoid"],
+	[9, "hexagon"],
+	[10, "octagon"],
+	[13, "line"],
+	[20, "line"]
+]);
+function isLineShape(shapeType) {
+	return shapeType === 13 || shapeType >= 20 && shapeType <= 49;
+}
+function toCustomGeometry(g) {
+	const commands = g.commands.map((c) => c.kind === "move" ? {
+		cmd: "move",
+		x: c.x,
+		y: c.y
+	} : c.kind === "line" ? {
+		cmd: "line",
+		x: c.x,
+		y: c.y
+	} : c.kind === "cubic" ? {
+		cmd: "cubic",
+		x1: c.x1,
+		y1: c.y1,
+		x2: c.x2,
+		y2: c.y2,
+		x: c.x,
+		y: c.y
+	} : { cmd: "close" });
+	return {
+		pathWidth: g.pathWidth,
+		pathHeight: g.pathHeight,
+		commands
+	};
+}
+function positionedAutoShape(rect, auto) {
+	const line = isLineShape(auto.shapeType);
+	const fill = auto.fillColorHex && !line ? {
+		kind: "solid",
+		colorHex: auto.fillColorHex
+	} : { kind: "none" };
+	const stroke = auto.lineColorHex ? {
+		colorHex: auto.lineColorHex,
+		fill: "solid"
+	} : line ? { fill: "solid" } : void 0;
+	return {
+		kind: "shape",
+		shape: {
+			float: floatAt(rect),
+			width: pt(rect.w),
+			height: pt(rect.h),
+			geometry: auto.geometry ? {
+				kind: "custom",
+				custom: toCustomGeometry(auto.geometry)
+			} : {
+				kind: "preset",
+				preset: SHAPE_PRESETS.get(auto.shapeType) ?? "rect",
+				adjust: /* @__PURE__ */ new Map()
+			},
+			fill,
+			...stroke ? { line: stroke } : {},
+			paragraphProperties: {}
+		}
+	};
+}
+function inFlowImage(image, resources) {
+	const size = imagePixelSize(image.bytes);
+	if (!size) return void 0;
+	return {
+		kind: "image",
+		image: {
+			resource: resources.put(image.bytes),
+			width: pt(size.w * .75),
+			height: pt(size.h * .75),
+			paragraphProperties: {}
+		}
+	};
+}
+function imagePixelSize(d) {
+	if (d.length >= 24 && d[0] === 137 && d[1] === 80 && d[2] === 78 && d[3] === 71) {
+		const w = u32be(d, 16);
+		const h = u32be(d, 20);
+		return w > 0 && h > 0 ? {
+			w,
+			h
+		} : void 0;
+	}
+	if (d.length >= 4 && d[0] === 255 && d[1] === 216) {
+		let off = 2;
+		while (off + 9 < d.length) {
+			if (d[off] !== 255) {
+				off++;
+				continue;
+			}
+			const marker = d[off + 1];
+			if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+				const h = d[off + 5] << 8 | d[off + 6];
+				const w = d[off + 7] << 8 | d[off + 8];
+				return w > 0 && h > 0 ? {
+					w,
+					h
+				} : void 0;
+			}
+			const len = d[off + 2] << 8 | d[off + 3];
+			if (len < 2) break;
+			off += 2 + len;
+		}
+	}
+}
+function u32be(d, o) {
+	return (d[o] << 24 | d[o + 1] << 16 | d[o + 2] << 8 | d[o + 3]) >>> 0;
+}
+function toRun(r) {
+	const underline = r.underline ? "single" : void 0;
+	const properties = {
+		...r.bold ? { bold: true } : {},
+		...r.italic ? { italic: true } : {},
+		...underline ? { underline } : {},
+		...r.sizePt ? { fontSizePt: pt(r.sizePt) } : {},
+		...r.colorHex ? { colorHex: r.colorHex } : {}
+	};
+	return {
+		text: r.text,
+		properties
+	};
+}
+function toParaProperties(p, breakBefore) {
+	const alignment = p.align !== void 0 ? alignmentFrom(p.align) : void 0;
+	const level = p.level ?? 0;
+	return {
+		...breakBefore ? { pageBreakBefore: true } : {},
+		...alignment ? { alignment } : {},
+		...level > 0 ? { indentLeft: pt(level * LEVEL_INDENT_PT) } : {}
+	};
+}
+function alignmentFrom(a) {
+	switch (a) {
+		case 1: return "center";
+		case 2: return "right";
+		case 3:
+		case 6: return "both";
+		case 4:
+		case 5: return "distribute";
+		default: return;
+	}
+}
+function anchorParagraph(breakBefore) {
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: breakBefore ? { pageBreakBefore: true } : {},
+			runs: [{
+				text: ZERO_WIDTH_SPACE,
+				properties: {}
+			}]
+		}
+	};
+}
+var pptReader = {
+	id: "ppt",
+	produces: "flow",
+	supports: new Set([FEATURES.text]),
+	sniff: looksLikePpt,
+	read: (bytes) => readPpt(bytes)
+};
+//#endregion
+export { pptReader };