reamkit 1.14.0 → 1.15.1

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

@@ -0,0 +1,756 @@
+import { isCfb, openCfb } from "../../core/ole/cfb.js";
+//#region src/pptx/ppt/ppt-text.ts
+var RT_DOCUMENT = 1e3;
+var RT_DOCUMENT_ATOM = 1001;
+var RT_SLIDE_LIST_WITH_TEXT = 4080;
+var RT_SLIDE_PERSIST_ATOM = 1011;
+var RT_SLIDE = 1006;
+var RT_USER_EDIT_ATOM = 4085;
+var RT_PERSIST_DIRECTORY_ATOM = 6002;
+var RT_DRAWING_GROUP = 1035;
+var RT_TEXT_HEADER_ATOM = 3999;
+var RT_TEXT_CHARS_ATOM = 4e3;
+var RT_STYLE_TEXT_PROP_ATOM = 4001;
+var RT_TEXT_BYTES_ATOM = 4008;
+var RT_SLIDE_ATOM = 1007;
+var RT_MAIN_MASTER = 1016;
+var RT_COLOR_SCHEME_ATOM = 2032;
+var FBT_BSTORE_CONTAINER = 61441;
+var FBT_BSE = 61447;
+var FBT_SP_CONTAINER = 61444;
+var FBT_FSP = 61450;
+var FBT_OPT = 61451;
+var FBT_CLIENT_TEXTBOX = 61453;
+var FBT_CLIENT_ANCHOR = 61456;
+var PROP_PIB = 260;
+var PROP_FILL_COLOR = 385;
+var PROP_LINE_COLOR = 448;
+var PROP_GEO_LEFT = 320;
+var PROP_GEO_TOP = 321;
+var PROP_GEO_RIGHT = 322;
+var PROP_GEO_BOTTOM = 323;
+var PROP_VERTICES = 325;
+var PROP_SEGMENT_INFO = 326;
+var COLOR_SCHEME_INSTANCE = 1;
+var SLIDE_FLAG_MASTER_SCHEME = 2;
+var COLORREF_SCHEME_INDEX = 8;
+var COLORREF_SYS_INDEX = 16;
+var FBSE_FODELAY_OFFSET = 28;
+var FSP_FLAG_PATRIARCH = 4;
+var TOKEN_ENCRYPTED = 4090610911;
+var SLWT_INSTANCE_SLIDES = 0;
+var MAX_EDITS = 4096;
+var MAX_DEPTH = 24;
+function recordAt(stream, off) {
+	if (off < 0 || off + 8 > stream.length) return void 0;
+	const verInstance = u16(stream, off);
+	const type = u16(stream, off + 2);
+	const recLen = u32(stream, off + 4);
+	const start = off + 8;
+	const end = Math.min(stream.length, start + recLen);
+	return {
+		type,
+		instance: verInstance >> 4,
+		isContainer: (verInstance & 15) === 15,
+		data: stream.subarray(start, end)
+	};
+}
+function* records(d) {
+	let off = 0;
+	while (off + 8 <= d.length) {
+		const rec = recordAt(d, off);
+		if (!rec) break;
+		yield rec;
+		const consumed = 8 + rec.data.length;
+		if (consumed <= 0) break;
+		off += consumed;
+	}
+}
+function extractPptContent(bytes) {
+	const empty = {
+		slides: [],
+		encrypted: false
+	};
+	if (!isCfb(bytes)) return empty;
+	let cfb;
+	try {
+		cfb = openCfb(bytes);
+	} catch {
+		return empty;
+	}
+	const stream = cfb.readStream("PowerPoint Document");
+	if (!stream) return empty;
+	const currentUser = cfb.readStream("Current User");
+	if (currentUser && currentUser.length >= 16) {
+		if (u32(currentUser, 12) === TOKEN_ENCRYPTED) return {
+			slides: [],
+			encrypted: true
+		};
+	}
+	let currentEditOffset = currentUser && currentUser.length >= 20 ? u32(currentUser, 16) : 0;
+	if (currentEditOffset === 0 || currentEditOffset + 8 > stream.length) currentEditOffset = findLastUserEdit(stream);
+	const { persist, docPersistId } = buildPersistDirectory(stream, currentEditOffset);
+	const docOffset = docPersistId !== void 0 ? persist.get(docPersistId) : void 0;
+	const docRec = docOffset !== void 0 ? recordAt(stream, docOffset) : findDocument(stream);
+	const noImages = {
+		foDelays: [],
+		pictures: new Uint8Array(0)
+	};
+	if (!docRec || docRec.type !== RT_DOCUMENT) return {
+		slides: slidesByScan(stream, noImages),
+		encrypted: false
+	};
+	const img = {
+		foDelays: parseFbseStore(docRec.data),
+		pictures: cfb.readStream("Pictures") ?? new Uint8Array(0)
+	};
+	const slides = readSlideList(stream, docRec.data, persist, img);
+	const hasContent = slides.some(slideHasContent);
+	const size = readSlideSize(docRec.data);
+	return {
+		slides: hasContent ? slides : slidesByScan(stream, img),
+		...size ?? {},
+		encrypted: false
+	};
+}
+function slideHasContent(s) {
+	return s.shapes.some((sh) => shapeHasText(sh) || sh.image !== void 0 || sh.autoShape !== void 0);
+}
+function shapeHasText(sh) {
+	return sh.paragraphs?.some((p) => paragraphText(p).length > 0) ?? false;
+}
+function slideShapes(slideData, img, outline, scheme) {
+	const shapes = collectShapes(slideData, img, scheme);
+	if (!shapes.some(shapeHasText)) {
+		const inline = collectParagraphs(slideData, 0);
+		const text = inline.some((p) => paragraphText(p).length > 0) ? inline : outline;
+		if (text.some((p) => paragraphText(p).length > 0)) shapes.push({ paragraphs: text });
+	}
+	return shapes;
+}
+function buildPersistDirectory(stream, currentEditOffset) {
+	const persist = /* @__PURE__ */ new Map();
+	let docPersistId;
+	let editOff = currentEditOffset;
+	for (let guard = 0; editOff !== 0 && guard < MAX_EDITS; guard++) {
+		const edit = recordAt(stream, editOff);
+		if (!edit || edit.type !== RT_USER_EDIT_ATOM || edit.data.length < 20) break;
+		const offsetLastEdit = u32(edit.data, 8);
+		const offsetPersistDir = u32(edit.data, 12);
+		if (docPersistId === void 0) docPersistId = u32(edit.data, 16);
+		mergePersistDirectory(stream, offsetPersistDir, persist);
+		if (offsetLastEdit >= editOff) break;
+		editOff = offsetLastEdit;
+	}
+	return {
+		persist,
+		docPersistId
+	};
+}
+function mergePersistDirectory(stream, offset, persist) {
+	const dir = recordAt(stream, offset);
+	if (!dir || dir.type !== RT_PERSIST_DIRECTORY_ATOM) return;
+	const d = dir.data;
+	let p = 0;
+	while (p + 4 <= d.length) {
+		const persistIdAndCnt = u32(d, p);
+		p += 4;
+		const startId = persistIdAndCnt & 1048575;
+		const count = persistIdAndCnt >>> 20 & 4095;
+		for (let i = 0; i < count && p + 4 <= d.length; i++) {
+			const off = u32(d, p);
+			p += 4;
+			if (!persist.has(startId + i)) persist.set(startId + i, off);
+		}
+	}
+}
+function readSlideList(stream, docData, persist, img) {
+	const slwt = findChild(docData, (r) => r.type === RT_SLIDE_LIST_WITH_TEXT && r.instance === SLWT_INSTANCE_SLIDES);
+	if (!slwt) return [];
+	const slides = [];
+	let outline = [];
+	let pendingRef;
+	const flush = () => {
+		if (pendingRef === void 0) return;
+		const slideOff = persist.get(pendingRef);
+		const slideRec = slideOff !== void 0 ? recordAt(stream, slideOff) : void 0;
+		const shapes = slideRec !== void 0 && slideRec.type === RT_SLIDE ? slideShapes(slideRec.data, img, outline, resolveScheme(slideRec.data, persist, stream)) : outline.some((p) => paragraphText(p).length > 0) ? [{ paragraphs: outline }] : [];
+		slides.push({ shapes });
+		outline = [];
+		pendingRef = void 0;
+	};
+	const recs = [...records(slwt)];
+	for (let i = 0; i < recs.length; i++) {
+		const rec = recs[i];
+		if (rec.type === RT_SLIDE_PERSIST_ATOM) {
+			flush();
+			pendingRef = rec.data.length >= 4 ? u32(rec.data, 0) : void 0;
+		} else if (rec.type === RT_TEXT_CHARS_ATOM || rec.type === RT_TEXT_BYTES_ATOM) outline.push(...styledParagraphs(rec, findFollowingStyle(recs, i)));
+	}
+	flush();
+	return slides;
+}
+function collectParagraphs(d, depth) {
+	if (depth > MAX_DEPTH) return [];
+	const out = [];
+	const recs = [...records(d)];
+	for (let i = 0; i < recs.length; i++) {
+		const rec = recs[i];
+		if (rec.type === RT_TEXT_CHARS_ATOM || rec.type === RT_TEXT_BYTES_ATOM) out.push(...styledParagraphs(rec, findFollowingStyle(recs, i)));
+		else if (rec.isContainer) out.push(...collectParagraphs(rec.data, depth + 1));
+	}
+	return out;
+}
+function findFollowingStyle(recs, i) {
+	for (let j = i + 1; j < recs.length; j++) {
+		const t = recs[j].type;
+		if (t === RT_STYLE_TEXT_PROP_ATOM) return recs[j].data;
+		if (t === RT_TEXT_CHARS_ATOM || t === RT_TEXT_BYTES_ATOM || t === RT_TEXT_HEADER_ATOM) break;
+	}
+}
+function styledParagraphs(textRec, styleData) {
+	return buildStyledParagraphs(textRec.type === RT_TEXT_CHARS_ATOM ? decodeUtf16(textRec.data) : decodeCp1252(textRec.data), styleData);
+}
+function slidesByScan(stream, img) {
+	const slides = [];
+	collectSlides(stream, slides, img, 0);
+	return slides;
+}
+function collectSlides(d, out, img, depth) {
+	if (depth > MAX_DEPTH) return;
+	for (const rec of records(d)) if (rec.type === RT_SLIDE) out.push({ shapes: slideShapes(rec.data, img, [], resolveScheme(rec.data)) });
+	else if (rec.isContainer) collectSlides(rec.data, out, img, depth + 1);
+}
+function findChild(d, pred) {
+	for (const rec of records(d)) if (pred(rec)) return rec.data;
+}
+function findDocument(stream) {
+	for (const rec of records(stream)) if (rec.type === RT_DOCUMENT) return rec;
+}
+function findLastUserEdit(stream) {
+	let off = 0;
+	let last = 0;
+	while (off + 8 <= stream.length) {
+		const rec = recordAt(stream, off);
+		if (!rec) break;
+		if (rec.type === RT_USER_EDIT_ATOM) last = off;
+		const consumed = 8 + rec.data.length;
+		if (consumed <= 0) break;
+		off += consumed;
+	}
+	return last;
+}
+var MASTER_UNITS_PER_INCH = 576;
+var POINTS_PER_INCH = 72;
+function readSlideSize(docData) {
+	const atom = findChild(docData, (r) => r.type === RT_DOCUMENT_ATOM);
+	if (!atom || atom.length < 8) return void 0;
+	const cx = i32(atom, 0);
+	const cy = i32(atom, 4);
+	const toPt = (u) => u / MASTER_UNITS_PER_INCH * POINTS_PER_INCH;
+	const w = toPt(cx);
+	const h = toPt(cy);
+	if (w < 216 || w > 4320 || h < 216 || h > 4320) return void 0;
+	return {
+		slideWidthPt: w,
+		slideHeightPt: h
+	};
+}
+function parseFbseStore(docData) {
+	const group = findChild(docData, (r) => r.type === RT_DRAWING_GROUP);
+	if (!group) return [];
+	const store = findDescendantContainer(group, FBT_BSTORE_CONTAINER, 0);
+	if (!store) return [];
+	const foDelays = [];
+	for (const r of records(store)) if (r.type === FBT_BSE) foDelays.push(r.data.length >= FBSE_FODELAY_OFFSET + 4 ? u32(r.data, FBSE_FODELAY_OFFSET) : 0);
+	return foDelays;
+}
+function findDescendantContainer(d, type, depth) {
+	if (depth > MAX_DEPTH) return void 0;
+	for (const r of records(d)) {
+		if (r.type === type) return r.data;
+		if (r.isContainer) {
+			const found = findDescendantContainer(r.data, type, depth + 1);
+			if (found) return found;
+		}
+	}
+}
+function collectShapes(slideData, img, scheme) {
+	const out = [];
+	collectShapeContainers(slideData, img, out, 0, scheme);
+	return out;
+}
+function collectShapeContainers(d, img, out, depth, scheme) {
+	if (depth > MAX_DEPTH) return;
+	for (const r of records(d)) if (r.type === FBT_SP_CONTAINER) {
+		let rectPt;
+		let paragraphs;
+		let pib;
+		let shapeType = 0;
+		let fspFlags = 0;
+		let fillColorHex;
+		let lineColorHex;
+		let geometry;
+		for (const child of records(r.data)) if (child.type === FBT_FSP) {
+			shapeType = child.instance;
+			fspFlags = child.data.length >= 8 ? u32(child.data, 4) : 0;
+		} else if (child.type === FBT_CLIENT_ANCHOR) rectPt = parseAnchor(child.data);
+		else if (child.type === FBT_CLIENT_TEXTBOX) paragraphs = collectParagraphs(child.data, 0);
+		else if (child.type === FBT_OPT) {
+			pib = optProperty(child.data, child.instance, PROP_PIB);
+			fillColorHex = optColor(child.data, child.instance, PROP_FILL_COLOR, scheme);
+			lineColorHex = optColor(child.data, child.instance, PROP_LINE_COLOR, scheme);
+			geometry = parseFreeformGeometry(child.data, child.instance);
+		}
+		let image;
+		if (pib !== void 0 && pib >= 1 && pib <= img.foDelays.length) {
+			const bytes = readBlipBytes(img.pictures, img.foDelays[pib - 1]);
+			if (bytes) image = { bytes };
+		}
+		const textParas = paragraphs && paragraphs.some((p) => paragraphText(p).length > 0) ? paragraphs : void 0;
+		const decorative = (fspFlags & (FSP_FLAG_PATRIARCH | 1025)) === 0;
+		const autoShape = !textParas && !image && rectPt && (shapeType > 0 || geometry) && decorative && (fillColorHex || lineColorHex) ? {
+			shapeType,
+			...fillColorHex ? { fillColorHex } : {},
+			...lineColorHex ? { lineColorHex } : {},
+			...geometry ? { geometry } : {}
+		} : void 0;
+		if (textParas || image || autoShape) out.push({
+			...rectPt ? { rectPt } : {},
+			...textParas ? { paragraphs: textParas } : {},
+			...image ? { image } : {},
+			...autoShape ? { autoShape } : {}
+		});
+	} else if (r.isContainer) collectShapeContainers(r.data, img, out, depth + 1, scheme);
+}
+function parseAnchor(data) {
+	let top;
+	let left;
+	let right;
+	let bottom;
+	if (data.length >= 16) {
+		top = i32(data, 0);
+		left = i32(data, 4);
+		right = i32(data, 8);
+		bottom = i32(data, 12);
+	} else if (data.length >= 8) {
+		top = i16(data, 0);
+		left = i16(data, 2);
+		right = i16(data, 4);
+		bottom = i16(data, 6);
+	} else return;
+	const x = left / 8;
+	const y = top / 8;
+	const w = (right - left) / 8;
+	const h = (bottom - top) / 8;
+	if (!(w > 0 && h > 0) || w > 5e3 || h > 5e3 || Math.abs(x) > 5e3 || Math.abs(y) > 5e3) return;
+	return {
+		x,
+		y,
+		w,
+		h
+	};
+}
+function optProperty(d, count, wantId) {
+	for (let i = 0; i < count && i * 6 + 6 <= d.length; i++) {
+		const id = u16(d, i * 6);
+		if ((id & 16383) === wantId && (id & 32768) === 0) return u32(d, i * 6 + 2);
+	}
+}
+function optComplex(d, count, wantId) {
+	let offset = count * 6;
+	for (let i = 0; i < count && i * 6 + 6 <= d.length; i++) {
+		const id = u16(d, i * 6);
+		if ((id & 32768) === 0) continue;
+		const len = u32(d, i * 6 + 2);
+		if ((id & 16383) === wantId) return offset + len <= d.length && len > 0 ? d.subarray(offset, offset + len) : void 0;
+		offset += len;
+	}
+}
+function arrayHeader(blob) {
+	if (blob.length < 6) return void 0;
+	const raw = u16(blob, 4);
+	const signed = raw >= 32768 ? raw - 65536 : raw;
+	const size = signed < 0 ? -signed >> 2 : signed;
+	if (size <= 0) return void 0;
+	return {
+		count: u16(blob, 0),
+		size,
+		base: 6
+	};
+}
+function signedLong(v) {
+	return v === void 0 ? void 0 : v >= 2147483648 ? v - 4294967296 : v;
+}
+var MAX_PATH_ELEMS = 2e4;
+function parseFreeformGeometry(d, count) {
+	const vBlob = optComplex(d, count, PROP_VERTICES);
+	const sBlob = optComplex(d, count, PROP_SEGMENT_INFO);
+	if (!vBlob || !sBlob) return void 0;
+	const vh = arrayHeader(vBlob);
+	if (!vh || vh.count > MAX_PATH_ELEMS) return void 0;
+	const verts = [];
+	for (let i = 0; i < vh.count; i++) {
+		const off = vh.base + i * vh.size;
+		if (off + vh.size > vBlob.length) break;
+		if (vh.size >= 8) verts.push({
+			x: i32(vBlob, off),
+			y: i32(vBlob, off + 4)
+		});
+		else if (vh.size >= 4) verts.push({
+			x: i16(vBlob, off),
+			y: i16(vBlob, off + 2)
+		});
+		else return void 0;
+	}
+	if (verts.length === 0) return void 0;
+	const sh = arrayHeader(sBlob);
+	if (!sh || sh.size < 2 || sh.count > MAX_PATH_ELEMS) return void 0;
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const v of verts) {
+		if (v.x < minX) minX = v.x;
+		if (v.x > maxX) maxX = v.x;
+		if (v.y < minY) minY = v.y;
+		if (v.y > maxY) maxY = v.y;
+	}
+	const left = signedLong(optProperty(d, count, PROP_GEO_LEFT)) ?? minX;
+	const top = signedLong(optProperty(d, count, PROP_GEO_TOP)) ?? minY;
+	const right = signedLong(optProperty(d, count, PROP_GEO_RIGHT)) ?? maxX;
+	const bottom = signedLong(optProperty(d, count, PROP_GEO_BOTTOM)) ?? maxY;
+	const pathWidth = right - left;
+	const pathHeight = bottom - top;
+	if (!(pathWidth > 0) || !(pathHeight > 0) || pathWidth > 1e7 || pathHeight > 1e7) return void 0;
+	const commands = [];
+	let vi = 0;
+	let drew = false;
+	for (let i = 0; i < sh.count; i++) {
+		const off = sh.base + i * sh.size;
+		if (off + 2 > sBlob.length) break;
+		const type = u16(sBlob, off) >> 13 & 7;
+		if (type === 2) {
+			const v = verts[vi++];
+			if (!v) break;
+			commands.push({
+				kind: "move",
+				x: v.x - left,
+				y: v.y - top
+			});
+		} else if (type === 0) {
+			const v = verts[vi++];
+			if (!v) break;
+			commands.push({
+				kind: "line",
+				x: v.x - left,
+				y: v.y - top
+			});
+			drew = true;
+		} else if (type === 1) {
+			const c1 = verts[vi++];
+			const c2 = verts[vi++];
+			const e = verts[vi++];
+			if (!c1 || !c2 || !e) break;
+			commands.push({
+				kind: "cubic",
+				x1: c1.x - left,
+				y1: c1.y - top,
+				x2: c2.x - left,
+				y2: c2.y - top,
+				x: e.x - left,
+				y: e.y - top
+			});
+			drew = true;
+		} else if (type === 3) commands.push({ kind: "close" });
+		else if (type === 4) break;
+		else if (type === 5) {
+			if ((u16(sBlob, off) >> 8 & 31) < 10) return void 0;
+		}
+	}
+	return drew ? {
+		pathWidth,
+		pathHeight,
+		commands
+	} : void 0;
+}
+var SYS_COLORS = new Map([
+	[5, "FFFFFF"],
+	[6, "000000"],
+	[7, "000000"],
+	[8, "000000"],
+	[13, "0078D7"],
+	[14, "FFFFFF"],
+	[15, "F0F0F0"],
+	[16, "A0A0A0"],
+	[18, "000000"],
+	[20, "FFFFFF"],
+	[23, "000000"],
+	[24, "FFFFE1"]
+]);
+function optColor(d, count, wantId, scheme) {
+	const v = optProperty(d, count, wantId);
+	if (v === void 0) return void 0;
+	const flags = v >>> 24;
+	if (flags === 0) return `${hex2(v & 255)}${hex2(v >> 8 & 255)}${hex2(v >> 16 & 255)}`;
+	if (flags === COLORREF_SCHEME_INDEX && scheme) {
+		const idx = v & 255;
+		if (idx < scheme.length) return scheme[idx];
+	}
+	if (flags === COLORREF_SYS_INDEX) return SYS_COLORS.get(v & 65535);
+}
+function resolveScheme(slideData, persist, stream) {
+	let schemeData = findColorScheme(slideData);
+	const slideAtom = findChild(slideData, (r) => r.type === RT_SLIDE_ATOM);
+	if (slideAtom && slideAtom.length >= 22 && persist && stream) {
+		if ((u16(slideAtom, 20) & SLIDE_FLAG_MASTER_SCHEME) !== 0) {
+			const masterOff = persist.get(u32(slideAtom, 12));
+			const masterRec = masterOff !== void 0 ? recordAt(stream, masterOff) : void 0;
+			if (masterRec && masterRec.type === RT_MAIN_MASTER) {
+				const masterScheme = findColorScheme(masterRec.data);
+				if (masterScheme) schemeData = masterScheme;
+			}
+		}
+	}
+	return schemeData ? parseColorScheme(schemeData) : void 0;
+}
+function findColorScheme(containerData) {
+	return findChild(containerData, (r) => r.type === RT_COLOR_SCHEME_ATOM && r.instance === COLOR_SCHEME_INSTANCE);
+}
+function parseColorScheme(d) {
+	if (d.length < 32) return void 0;
+	const colors = [];
+	for (let i = 0; i < 8; i++) {
+		const o = i * 4;
+		colors.push(`${hex2(d[o])}${hex2(d[o + 1])}${hex2(d[o + 2])}`);
+	}
+	return colors;
+}
+function readBlipBytes(pictures, foDelay) {
+	if (foDelay < 0 || foDelay + 8 > pictures.length) return void 0;
+	const recLen = u32(pictures, foDelay + 4);
+	const start = foDelay + 8;
+	const blip = pictures.subarray(start, Math.min(pictures.length, start + recLen));
+	const limit = Math.min(blip.length, 80);
+	for (let off = 0; off < limit; off++) for (const magic of IMAGE_MAGICS) if (matchesMagic(blip, off, magic)) return blip.subarray(off);
+}
+var IMAGE_MAGICS = [[
+	137,
+	80,
+	78,
+	71
+], [
+	255,
+	216,
+	255
+]];
+function matchesMagic(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;
+}
+function paragraphText(p) {
+	return p.runs.map((r) => r.text).join("");
+}
+function buildStyledParagraphs(text, styleData) {
+	const style = styleData ? parseStyleTextProp(styleData, text.length) : void 0;
+	const charProps = style ? expandCharProps(style.charRuns, text.length) : void 0;
+	const paraRuns = style?.paraRuns ?? [];
+	const paras = [];
+	let runs = [];
+	let cur = "";
+	let curProps;
+	let paraIndex = 0;
+	const pushRun = () => {
+		if (cur.length > 0) runs.push(toRun(cur, curProps));
+		cur = "";
+	};
+	const endParagraph = () => {
+		pushRun();
+		const meta = paraRuns[paraIndex];
+		paras.push({
+			runs,
+			...meta?.align !== void 0 ? { align: meta.align } : {},
+			...meta?.level !== void 0 ? { level: meta.level } : {}
+		});
+		runs = [];
+		paraIndex++;
+	};
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === 13) {
+			endParagraph();
+			continue;
+		}
+		const props = charProps?.[i];
+		if (cur.length > 0 && !sameProps(props, curProps)) pushRun();
+		if (cur.length === 0) curProps = props;
+		if (c === 11 || c === 10 || c === 9) cur += " ";
+		else if (c !== 65279 && c >= 32) cur += text[i];
+	}
+	endParagraph();
+	if (paras.length > 1 && paragraphText(paras[paras.length - 1]).length === 0) paras.pop();
+	return paras;
+}
+function toRun(text, props) {
+	if (!props) return { text };
+	return {
+		text,
+		...props.bold ? { bold: true } : {},
+		...props.italic ? { italic: true } : {},
+		...props.underline ? { underline: true } : {},
+		...props.sizePt ? { sizePt: props.sizePt } : {},
+		...props.colorHex ? { colorHex: props.colorHex } : {}
+	};
+}
+function sameProps(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return !!a.bold === !!b.bold && !!a.italic === !!b.italic && !!a.underline === !!b.underline && a.sizePt === b.sizePt && a.colorHex === b.colorHex;
+}
+function expandCharProps(charRuns, textLen) {
+	const out = [];
+	for (const run of charRuns) for (let i = 0; i < run.count && out.length < textLen; i++) out.push(run);
+	while (out.length < textLen) out.push(charRuns[charRuns.length - 1] ?? { count: 0 });
+	return out;
+}
+function parseStyleTextProp(data, textLen) {
+	const target = textLen + 1;
+	let off = 0;
+	const paraRuns = [];
+	let consumed = 0;
+	while (consumed < target && off + 10 <= data.length) {
+		const count = u32(data, off);
+		const level = u16(data, off + 4);
+		const mask = u32(data, off + 6);
+		off += 10;
+		let align;
+		if ((mask & 15) !== 0) off += 2;
+		if ((mask & 128) !== 0) off += 2;
+		if ((mask & 16) !== 0) off += 2;
+		if ((mask & 64) !== 0) off += 2;
+		if ((mask & 32) !== 0) off += 4;
+		if ((mask & 2048) !== 0) {
+			align = u16(data, off);
+			off += 2;
+		}
+		if ((mask & 4096) !== 0) off += 2;
+		if ((mask & 8192) !== 0) off += 2;
+		if ((mask & 16384) !== 0) off += 2;
+		if ((mask & 256) !== 0) off += 2;
+		if ((mask & 1024) !== 0) off += 2;
+		if ((mask & 32768) !== 0) off += 2;
+		if ((mask & 1048576) !== 0) off += 2 + (off + 2 <= data.length ? u16(data, off) : 0) * 4;
+		if ((mask & 65536) !== 0) off += 2;
+		if ((mask & 917504) !== 0) off += 2;
+		if ((mask & 2097152) !== 0) off += 2;
+		paraRuns.push({
+			count,
+			level,
+			...align !== void 0 ? { align } : {}
+		});
+		consumed += count;
+		if (count <= 0) break;
+	}
+	const charRuns = [];
+	consumed = 0;
+	while (consumed < target && off + 8 <= data.length) {
+		const count = u32(data, off);
+		const mask = u32(data, off + 4);
+		off += 8;
+		const run = { count };
+		if ((mask & 16055) !== 0) {
+			const style = u16(data, off);
+			off += 2;
+			if ((mask & 1) !== 0 && (style & 1) !== 0) run.bold = true;
+			if ((mask & 2) !== 0 && (style & 2) !== 0) run.italic = true;
+			if ((mask & 4) !== 0 && (style & 4) !== 0) run.underline = true;
+		}
+		if ((mask & 65536) !== 0) off += 2;
+		if ((mask & 2097152) !== 0) off += 2;
+		if ((mask & 4194304) !== 0) off += 2;
+		if ((mask & 8388608) !== 0) off += 2;
+		if ((mask & 131072) !== 0) {
+			const sz = u16(data, off);
+			off += 2;
+			if (sz > 0) run.sizePt = sz;
+		}
+		if ((mask & 262144) !== 0) {
+			if (off + 4 <= data.length && data[off + 3] === 254) run.colorHex = hex2(data[off]) + hex2(data[off + 1]) + hex2(data[off + 2]);
+			off += 4;
+		}
+		if ((mask & 524288) !== 0) off += 2;
+		charRuns.push(run);
+		consumed += count;
+		if (count <= 0) break;
+	}
+	return paraRuns.length > 0 || charRuns.length > 0 ? {
+		paraRuns,
+		charRuns
+	} : void 0;
+}
+function hex2(n) {
+	return n.toString(16).padStart(2, "0").toUpperCase();
+}
+function decodeUtf16(d) {
+	let out = "";
+	for (let i = 0; i + 1 < d.length; i += 2) out += String.fromCharCode(d[i] | d[i + 1] << 8);
+	return out;
+}
+var CP1252_HIGH = [
+	8364,
+	129,
+	8218,
+	402,
+	8222,
+	8230,
+	8224,
+	8225,
+	710,
+	8240,
+	352,
+	8249,
+	338,
+	141,
+	381,
+	143,
+	144,
+	8216,
+	8217,
+	8220,
+	8221,
+	8226,
+	8211,
+	8212,
+	732,
+	8482,
+	353,
+	8250,
+	339,
+	157,
+	382,
+	376
+];
+function decodeCp1252(d) {
+	let out = "";
+	for (let i = 0; i < d.length; i++) {
+		const c = d[i];
+		out += String.fromCharCode(c >= 128 && c <= 159 ? CP1252_HIGH[c - 128] : c);
+	}
+	return out;
+}
+function u16(d, off) {
+	return (d[off] ?? 0) | (d[off + 1] ?? 0) << 8;
+}
+function u32(d, off) {
+	return ((d[off] ?? 0) | (d[off + 1] ?? 0) << 8 | (d[off + 2] ?? 0) << 16 | (d[off + 3] ?? 0) << 24) >>> 0;
+}
+function i32(d, off) {
+	return u32(d, off) | 0;
+}
+function i16(d, off) {
+	const v = u16(d, off);
+	return v >= 32768 ? v - 65536 : v;
+}
+//#endregion
+export { extractPptContent, paragraphText };