pptx-ts 0.0.1

package/dist/inspect.js

@@ -0,0 +1,317 @@
+import { d as emuToInches, l as STANDARD_LAYOUTS, x as warn } from "./units-1kRzYShk.js";
+import { a as TsPptxError, i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError, t as InternalError } from "./errors-Bvln0H-7.js";
+import { t as OOXML_NS } from "./namespaces-BVnNu7sg.js";
+import { Nt as attr, Wt as intValue, zt as firstChild } from "./shapes-BemroU-z.js";
+import { f as OpcPackage, t as Presentation } from "./presentation-Cp7vzlAw.js";
+//#region src/inspect.ts
+/**
+* A cheap, flat snapshot of what a `.pptx` contains: every element on every
+* slide, with its slide-absolute box and the handful of text/fill properties a
+* layout audit asks about.
+*
+* It is a **projection over `ts-pptx/read`**, not a second reader. `read` gives a
+* navigable, mutable model of a package and answers questions in the shape of the
+* OOXML tree; this answers one flat question — "what is on the slides, and where"
+* — in the shape a linter, an overlap check, or a diffing tool wants. The two used
+* to be independent implementations over two different XML parsers, which meant
+* every read-side fix had to be made twice and a divergence between them was
+* invisible to every test. Now the model below is the only reader, and this file
+* is the flattening.
+*
+* What it deliberately does NOT do, and why the projection is not just
+* `Presentation` re-exported:
+* - **Only geometry a shape carries itself.** A placeholder that inherits its box
+*   from the layout is omitted rather than resolved (`absoluteFrame`, not
+*   `resolvedFrame`) — the snapshot reports what the slide states.
+* - **A `p:graphicFrame` is a box, not its contents.** A table, chart or SmartArt
+*   graphic is reported as one element with its box, its kind, and the text a
+*   reader sees on the slide, but its structure is not flattened: no per-run
+*   formatting, no cells, no series. Walk `ts-pptx/read` for what is inside one.
+*/
+const DEFAULT_INSPECT_SLIDE_SIZE = Object.freeze({
+	widthIn: round(STANDARD_LAYOUTS.LAYOUT_WIDE.widthIn, 3),
+	heightIn: STANDARD_LAYOUTS.LAYOUT_WIDE.heightIn
+});
+/**
+* Load a `.pptx` as an {@link OpcPackage} — the same package model `ts-pptx/read`
+* uses, so a caller that starts here can hand the result straight to
+* `Presentation.fromPackage()` without re-reading the bytes.
+*
+* The input must be a real OPC package: a zip that merely contains some slide XML
+* but no `[Content_Types].xml` is rejected with a `PackageReadError`.
+*/
+async function loadPptxPackage(input) {
+	return OpcPackage.load(await input);
+}
+/** Every part in the package, as zip paths (`ppt/slides/slide1.xml`), sorted. */
+function listPptxParts(pptxPackage) {
+	return [...pptxPackage.parts.keys()].map(zipPathOf).sort();
+}
+/** Read a package part as UTF-8 text, or `null` when the part is absent. */
+async function readPptxTextPart(pptxPackage, path) {
+	const bytes = await readPptxBinaryPart(pptxPackage, path);
+	return bytes ? textDecoder.decode(bytes) : null;
+}
+/**
+* Read a package part as raw bytes — the binary sibling of {@link readPptxTextPart}
+* for embedded media (SVG/PNG/EMF blobs, fonts, …) that must not be UTF-8 decoded.
+* Returns `null` when the part is absent. The `Uint8Array` is browser-isomorphic;
+* Node consumers can wrap it with `Buffer.from(...)` if they need Buffer methods.
+*/
+async function readPptxBinaryPart(pptxPackage, path) {
+	return pptxPackage.part(partNameOf(path))?.bytes ?? null;
+}
+const textDecoder = new TextDecoder("utf-8");
+/** OPC partnames are absolute (`/ppt/…`); this surface speaks zip paths (`ppt/…`). */
+function zipPathOf(partName) {
+	return partName.startsWith("/") ? partName.slice(1) : partName;
+}
+function partNameOf(zipPath) {
+	return zipPath.startsWith("/") ? zipPath : `/${zipPath}`;
+}
+async function inspectPptx(input) {
+	const pptxPackage = await loadPptxPackage(input);
+	const slideSize = await readPresentationSize(pptxPackage);
+	return {
+		slideSize,
+		slides: await extractSlides(pptxPackage, slideSize)
+	};
+}
+async function readPresentationSize(pptxPackage, fallback = DEFAULT_INSPECT_SLIDE_SIZE) {
+	const size = presentationOf(pptxPackage)?.slideSize;
+	if (!size) return fallback;
+	return {
+		widthIn: round(size.widthIn, 3),
+		heightIn: round(size.heightIn, 3)
+	};
+}
+/**
+* Every slide in the deck, in **presentation order** (`p:sldIdLst`) — the order
+* PowerPoint shows them in, which is not the order their parts are named once a
+* deck has been reordered.
+*/
+async function extractSlides(pptxPackage, size) {
+	const slideSize = size || await readPresentationSize(pptxPackage);
+	const presentation = presentationOf(pptxPackage);
+	if (!presentation) return [];
+	return presentation.slides.map((slide, index) => {
+		const path = zipPathOf(slide.partName);
+		const harvested = [];
+		harvest(slide.shapes, null, harvested);
+		const elements = flatten(harvested, path);
+		const text = elements.map((el) => el.text).filter(Boolean).join(" ");
+		return {
+			index,
+			name: slide.name || `Slide ${index + 1}`,
+			path,
+			size: slideSize,
+			elements,
+			text,
+			wordCount: countWords(text)
+		};
+	});
+}
+/**
+* The deck's `Presentation`, or `null` when the package holds no readable
+* `presentation.xml`. Callers here are auditing files they did not author, so a
+* package that is a valid OPC container but not a presentation reports an empty
+* deck rather than throwing. `presentationPart` is the throw site: it rejects a
+* package with no — or more than one — office-document relationship.
+*/
+function presentationOf(pptxPackage) {
+	const presentation = Presentation.fromPackage(pptxPackage);
+	try {
+		return presentation.presentationPart.isXmlPart ? presentation : null;
+	} catch {
+		return null;
+	}
+}
+function overlapArea(a, b) {
+	return Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+}
+function boxAnchor(box, anchor, axis) {
+	if (axis === "x") {
+		if (anchor === "left") return box.x;
+		if (anchor === "right") return box.x + box.w;
+		return box.x + box.w / 2;
+	}
+	if (anchor === "top") return box.y;
+	if (anchor === "bottom") return box.y + box.h;
+	return box.y + box.h / 2;
+}
+/**
+* Flatten a shape list depth-first in document order: each shape is followed by
+* its descendants, which is both paint order and the order the
+* {@link PptxSlideElement.zIndex} contract promises. Every entry's index in `out`
+* is its zIndex. Returns the zIndices assigned at this level, which is what the
+* enclosing group records as its {@link PptxSlideElement.childZIndices}.
+*/
+function harvest(shapes, parentZIndex, out) {
+	const zIndices = [];
+	for (const shape of shapes) {
+		const entry = {
+			shape,
+			parentZIndex,
+			childZIndices: []
+		};
+		const zIndex = out.push(entry) - 1;
+		zIndices.push(zIndex);
+		if (shape.shapeType === "group") entry.childZIndices = harvest(shape.shapes, zIndex, out);
+	}
+	return zIndices;
+}
+/**
+* Turn harvested shapes into elements, dropping the ones with no resolvable slide
+* position. A dropped shape keeps its zIndex — the numbers are positions in the
+* shape tree, and renumbering them would silently repoint every `parentZIndex`.
+*/
+function flatten(harvested, slidePath) {
+	return harvested.map((entry, zIndex) => toElement(entry, zIndex, slidePath)).filter((element) => Boolean(element));
+}
+function toElement(entry, zIndex, slidePath) {
+	const { shape } = entry;
+	const frame = shape.absoluteFrame;
+	if (!frame) {
+		reportUnresolvable(shape, zIndex, slidePath);
+		return null;
+	}
+	const textFrame = shape.textFrame;
+	const paragraphs = textFrame ? textFrame.paragraphs.map((p) => ({ runs: p.runs.map(toRun) })) : [];
+	const textRuns = paragraphs.flatMap((paragraph) => paragraph.runs);
+	const runText = textRuns.map((run) => run.text).join("");
+	const text = (shape.shapeType === "graphicFrame" ? graphicFrameText(shape) : runText).replace(/\s+/g, " ").trim();
+	const kind = shape.shapeType === "group" ? "group" : shape.shapeType === "graphicFrame" ? "graphicFrame" : text ? "text" : shape.shapeType === "picture" ? "image" : "shape";
+	return {
+		id: shape.id ?? zIndex + 1,
+		name: shape.name || `${kind} ${zIndex + 1}`,
+		kind,
+		graphicKind: shape.shapeType === "graphicFrame" ? graphicKindOf(shape) : null,
+		zIndex,
+		box: {
+			x: emuToInches(frame.left),
+			y: emuToInches(frame.top),
+			w: emuToInches(frame.width),
+			h: emuToInches(frame.height)
+		},
+		rotation: frame.rotation,
+		flipH: frame.flipH,
+		flipV: frame.flipV,
+		parentZIndex: entry.parentZIndex,
+		childZIndices: entry.childZIndices,
+		text,
+		textWrap: textFrame?.bodyProperties?.wrap ?? null,
+		autofit: textFrame?.autofit ?? null,
+		autofitFontScale: textFrame?.autofitFontScale ?? null,
+		bodyInsets: readBodyInsets(textFrame),
+		textRuns,
+		paragraphs,
+		fontSizes: [...new Set(textRuns.map((run) => run.fontSizePt).filter((size) => size !== null))],
+		colors: [...new Set(textRuns.map((run) => run.color).filter((color) => Boolean(color)))],
+		fill: shape.fillColor,
+		line: shape.lineColor,
+		shapeType: shape.presetGeometry
+	};
+}
+/**
+* What a graphic frame hosts, from the same `a:graphicData/@uri` the read model's
+* `has*` predicates compare against. A frame that answers none of them is `'other'`
+* rather than dropped: a box the deck's author placed is on the slide whether or not
+* this library models its payload, and an overlap or coverage check that skipped it
+* would report a gap where a 3D model or an OLE object sits.
+*/
+function graphicKindOf(frame) {
+	if (frame.hasTable) return "table";
+	if (frame.hasChart) return "chart";
+	if (frame.hasChartEx) return "chartEx";
+	if (frame.hasDiagram) return "diagram";
+	return "other";
+}
+/**
+* The text a graphic frame puts on the slide: table cells in row order, or SmartArt
+* node text. Charts contribute nothing, matching `Slide.text` on the read model — a
+* chart's strings are data labels and axis titles that PowerPoint itself does not
+* treat as slide body text.
+*
+* Separators are single spaces rather than the read model's `	`/`
+`, because the
+* caller collapses whitespace anyway; the point here is only that cells do not run
+* together into one word.
+*/
+function graphicFrameText(frame) {
+	const table = frame.table;
+	if (table) return table.rows.map((row) => row.cells.map((cell) => cell.text).join(" ")).join(" ");
+	return frame.diagram?.text ?? "";
+}
+/** Project one read-model {@link Run} onto the flat run shape. */
+function toRun(run) {
+	return {
+		text: run.text,
+		fontSizePt: run.fontSizePt,
+		color: run.color,
+		fontFace: run.fontName,
+		bold: run.bold ?? false,
+		italic: run.italic ?? false,
+		strike: run.strike,
+		highlight: run.highlight?.hex ?? null,
+		charSpacingPt: run.charSpacingPt
+	};
+}
+const DEFAULT_INSET_LR_IN = .1;
+const DEFAULT_INSET_TB_IN = .05;
+const POINTS_PER_INCH = 72;
+function readBodyInsets(textFrame) {
+	const insets = textFrame?.bodyProperties?.insetsPt;
+	if (!insets) return null;
+	const inches = (pt, fallback) => pt === void 0 ? fallback : pt / POINTS_PER_INCH;
+	return {
+		left: inches(insets.left, DEFAULT_INSET_LR_IN),
+		top: inches(insets.top, DEFAULT_INSET_TB_IN),
+		right: inches(insets.right, DEFAULT_INSET_LR_IN),
+		bottom: inches(insets.bottom, DEFAULT_INSET_TB_IN)
+	};
+}
+/** Warn about a shape whose slide position cannot be resolved, unless it never claimed one. */
+function reportUnresolvable(shape, zIndex, slidePath) {
+	const element = shape.element_;
+	if (!hasBox(ownTransform(element), "a:off", "a:ext")) return;
+	const who = shape.name ? `"${shape.name}"` : `the element at zIndex ${zIndex}`;
+	if (enclosingGroupLacksTransform(element)) {
+		warn("inspect/group-transform-missing", `inspect: skipped ${who} on ${slidePath} — an enclosing group has no usable a:xfrm, so its slide position cannot be resolved.`);
+		return;
+	}
+	warn("inspect/group-transform-degenerate", `inspect: skipped ${who} on ${slidePath} — an enclosing group has a degenerate transform (zero a:chExt), so its slide position cannot be resolved.`);
+}
+/** The element's own `a:xfrm` — on `p:grpSpPr` for a group, `p:spPr` for every other kind. */
+function ownTransform(element) {
+	const props = firstChild(element, element.localName === "grpSp" ? "p:grpSpPr" : "p:spPr");
+	return props && firstChild(props, "a:xfrm");
+}
+/** Whether any enclosing `p:grpSp` fails to state a complete child-space mapping. */
+function enclosingGroupLacksTransform(element) {
+	for (let node = element.parentNode; node && node.nodeType === 1; node = node.parentNode) {
+		const parent = node;
+		if (parent.namespaceURI !== OOXML_NS.p || parent.localName !== "grpSp") return false;
+		const xfrm = ownTransform(parent);
+		if (!hasBox(xfrm, "a:off", "a:ext") || !hasBox(xfrm, "a:chOff", "a:chExt")) return true;
+	}
+	return false;
+}
+/** Whether a transform states a complete position + extent pair. */
+function hasBox(xfrm, offName, extName) {
+	if (!xfrm) return false;
+	const off = firstChild(xfrm, offName);
+	const ext = firstChild(xfrm, extName);
+	if (!off || !ext) return false;
+	return intValue(attr(off, "x")) !== null && intValue(attr(off, "y")) !== null && intValue(attr(ext, "cx")) !== null && intValue(attr(ext, "cy")) !== null;
+}
+function countWords(text) {
+	return text.split(/\s+/).filter(Boolean).length;
+}
+function round(value, digits) {
+	const factor = 10 ** digits;
+	return Math.round(value * factor) / factor;
+}
+//#endregion
+export { DEFAULT_INSPECT_SLIDE_SIZE, InternalError, InvalidOptionError, MediaError, PackageReadError, TsPptxError, UnsupportedFeatureError, boxAnchor, extractSlides, inspectPptx, listPptxParts, loadPptxPackage, overlapArea, readPptxBinaryPart, readPptxTextPart, readPresentationSize };
+
+//# sourceMappingURL=inspect.js.map

package/dist/inspect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.js","names":[],"sources":["../src/inspect.ts"],"sourcesContent":["/**\n * A cheap, flat snapshot of what a `.pptx` contains: every element on every\n * slide, with its slide-absolute box and the handful of text/fill properties a\n * layout audit asks about.\n *\n * It is a **projection over `ts-pptx/read`**, not a second reader. `read` gives a\n * navigable, mutable model of a package and answers questions in the shape of the\n * OOXML tree; this answers one flat question — \"what is on the slides, and where\"\n * — in the shape a linter, an overlap check, or a diffing tool wants. The two used\n * to be independent implementations over two different XML parsers, which meant\n * every read-side fix had to be made twice and a divergence between them was\n * invisible to every test. Now the model below is the only reader, and this file\n * is the flattening.\n *\n * What it deliberately does NOT do, and why the projection is not just\n * `Presentation` re-exported:\n * - **Only geometry a shape carries itself.** A placeholder that inherits its box\n *   from the layout is omitted rather than resolved (`absoluteFrame`, not\n *   `resolvedFrame`) — the snapshot reports what the slide states.\n * - **A `p:graphicFrame` is a box, not its contents.** A table, chart or SmartArt\n *   graphic is reported as one element with its box, its kind, and the text a\n *   reader sees on the slide, but its structure is not flattened: no per-run\n *   formatting, no cells, no series. Walk `ts-pptx/read` for what is inside one.\n */\nimport { warn } from './diagnostics.js'\nimport { OpcPackage } from './read/opc/package.js'\nimport { Presentation } from './read/api/presentation.js'\nimport type { AnyShape } from './read/api/shapes.js'\nimport type { GraphicFrame } from './read/api/shapes/graphic-frame.js'\nimport type { Run, TextFrame } from './read/api/text.js'\nimport { ELEMENT_NODE, OOXML_NS, attr, firstChild, intValue, type Element } from './read/oxml/dom.js'\nimport { STANDARD_LAYOUTS, emuToInches } from './units.js'\n\n/**\n * Input to the inspect surface. A `string` is a **filesystem path** (Node) read\n * from disk; pass `Uint8Array`/`ArrayBuffer`/`Blob`/`number[]` for an in-memory\n * archive. (A string is a path, not JSZip's latin1 binary content — see\n * {@link ZipInput}.)\n */\ntype PptxInspectInputValue = string | number[] | Uint8Array | ArrayBuffer | Blob\n\nexport type PptxInspectInput = PptxInspectInputValue | Promise<PptxInspectInputValue>\n\nexport interface PptxSlideSize {\n\twidthIn: number\n\theightIn: number\n}\n\nexport interface PptxBox {\n\tx: number\n\ty: number\n\tw: number\n\th: number\n}\n\nexport interface PptxTextRun {\n\ttext: string\n\tfontSizePt: number | null\n\tcolor: string | null\n\t/** Run font face (`a:rPr > a:latin@typeface`), or null when it inherits from the theme/placeholder. */\n\tfontFace: string | null\n\t/** Bold (`a:rPr@b`). */\n\tbold: boolean\n\t/** Italic (`a:rPr@i`). */\n\titalic: boolean\n\t/** Strikethrough token (`a:rPr@strike`: `noStrike`/`sngStrike`/`dblStrike`), or null when unset. */\n\tstrike: string | null\n\t/** Highlight colour hex (`a:rPr > a:highlight`), or null when unset. A theme token is resolved against the slide's theme. */\n\thighlight: string | null\n\t/** Character spacing in points (`a:rPr@spc`, authored in hundredths of a point), or null when unset. */\n\tcharSpacingPt: number | null\n}\n\n/**\n * One paragraph (`a:p`): its runs in document order. Preserves the paragraph/line\n * boundaries that the flat {@link PptxSlideElement.textRuns} list discards — needed\n * to measure a `wrap=\"none\"` frame line-by-line (each paragraph is one unwrapped line).\n */\nexport interface PptxParagraph {\n\truns: PptxTextRun[]\n}\n\n/**\n * What an element is. `'group'` is a `p:grpSp` container: it has its own identity,\n * box, and fill, but no text of its own — its content is the elements that name it\n * in {@link PptxSlideElement.parentZIndex}. `'graphicFrame'` is a `p:graphicFrame`\n * hosting a table, a chart or a SmartArt graphic; {@link PptxSlideElement.graphicKind}\n * says which, and it keeps that kind even when it carries text (a `'text'` element is\n * always a `p:sp`).\n */\nexport type PptxSlideElementKind = 'text' | 'image' | 'shape' | 'group' | 'graphicFrame'\n\n/**\n * What a `'graphicFrame'` element hosts, read from its `a:graphicData/@uri`:\n * a table (`a:tbl`), a classic chart (`c:chart`), a 2016-family chart\n * (`cx:chartSpace`: waterfall/funnel/treemap/…), or a SmartArt diagram. `'other'`\n * is a frame whose URI matches none of those — an OLE object, an ink part, a 3D\n * model — reported as a box so it is not silently missing from the slide.\n */\nexport type PptxGraphicKind = 'table' | 'chart' | 'chartEx' | 'diagram' | 'other'\n\n/**\n * Vertical-autofit mode of a text frame, read from the `a:bodyPr` child element:\n * - `'none'`: no autofit (`a:noAutofit`, or no autofit child at all). The box has a\n *   fixed height the text must fit inside — a genuine overflow candidate.\n * - `'normAutofit'`: shrink text to fit (`a:normAutofit`, ts-pptx `fit: 'shrink'`).\n *   Text is downscaled rather than overflowing.\n * - `'spAutoFit'`: resize shape to fit text (`a:spAutoFit`, ts-pptx `fit: 'resize'`).\n *   The authored height is an output, not a constraint, so the box cannot overflow.\n */\nexport type PptxAutofitMode = 'none' | 'normAutofit' | 'spAutoFit'\n\n/**\n * Text-frame body insets in inches (`a:bodyPr` `lIns`/`tIns`/`rIns`/`bIns`), with\n * PowerPoint defaults applied when an attribute is absent (0.1in left/right,\n * 0.05in top/bottom). Subtract these from {@link PptxBox} to get the inner text box.\n */\nexport interface PptxBodyInsets {\n\tleft: number\n\ttop: number\n\tright: number\n\tbottom: number\n}\n\nexport interface PptxSlideElement {\n\tid: string | number\n\tname: string\n\tkind: PptxSlideElementKind\n\t/**\n\t * What a `'graphicFrame'` element hosts, or `null` for every other kind. See\n\t * {@link PptxGraphicKind}.\n\t */\n\tgraphicKind: PptxGraphicKind | null\n\t/**\n\t * Paint order on the slide, `0`-based: the element's position in a depth-first\n\t * walk of `p:spTree` in document order. A group is immediately followed by its\n\t * own children, which is also the order PowerPoint paints them, so a higher\n\t * `zIndex` draws on top. Unique within a slide, which is what\n\t * {@link parentZIndex} / {@link childZIndices} key on.\n\t */\n\tzIndex: number\n\t/**\n\t * Position and size in **slide-absolute** inches, composing every enclosing\n\t * group transform — directly comparable across elements whether or not they are\n\t * grouped. For a rotated element this is the unrotated placement box (the box\n\t * PowerPoint writes after Ungroup); see {@link rotation}.\n\t */\n\tbox: PptxBox\n\t/**\n\t * Effective clockwise rotation in degrees, normalised to `[0, 360)`, after\n\t * composing the element's own `a:xfrm@rot` with every enclosing group rotation.\n\t */\n\trotation: number\n\t/** Effective horizontal flip, XOR-composing the element's own `@flipH` with enclosing group flips. */\n\tflipH: boolean\n\t/** Effective vertical flip, XOR-composing the element's own `@flipV` with enclosing group flips. */\n\tflipV: boolean\n\t/** {@link zIndex} of the enclosing `'group'` element, or `null` when the element sits at slide level. */\n\tparentZIndex: number | null\n\t/** {@link zIndex} of each direct child, in document order. Empty unless {@link kind} is `'group'`. */\n\tchildZIndices: number[]\n\t/**\n\t * The element's text, whitespace-collapsed to one line. For a `'graphicFrame'`\n\t * this is the text the structure puts on the slide (table cells in row order,\n\t * SmartArt node text), which is what {@link PptxSlideInspection.text} and\n\t * `wordCount` then count; a chart contributes nothing, matching `Slide.text` on\n\t * the read model. That text has no {@link textRuns} or {@link paragraphs} here —\n\t * per-run formatting inside a structure is what this surface does not flatten.\n\t */\n\ttext: string\n\ttextWrap: string | null\n\tautofit: PptxAutofitMode | null\n\t/**\n\t * Baked shrink scale from `<a:normAutofit@fontScale>` as a percent (62.5 = 62.5%),\n\t * or null when the frame has no `normAutofit` or bakes no scale (a bare\n\t * `<a:normAutofit/>`, which PowerPoint draws at 100% until edited).\n\t */\n\tautofitFontScale: number | null\n\tbodyInsets: PptxBodyInsets | null\n\ttextRuns: PptxTextRun[]\n\t/** Runs grouped by their source paragraph (`a:p`), in document order. */\n\tparagraphs: PptxParagraph[]\n\tfontSizes: number[]\n\tcolors: string[]\n\tfill: string | null\n\tline: string | null\n\tshapeType: string | null\n}\n\nexport interface PptxSlideInspection {\n\tindex: number\n\tname: string\n\tpath: string\n\tsize: PptxSlideSize\n\telements: PptxSlideElement[]\n\ttext: string\n\twordCount: number\n}\n\nexport interface PptxInspection {\n\tslideSize: PptxSlideSize\n\tslides: PptxSlideInspection[]\n}\n\nexport type PptxBoxAxis = 'x' | 'y'\nexport type PptxBoxAnchor = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom'\n\nexport const DEFAULT_INSPECT_SLIDE_SIZE: PptxSlideSize = Object.freeze({\n\twidthIn: round(STANDARD_LAYOUTS.LAYOUT_WIDE.widthIn, 3),\n\theightIn: STANDARD_LAYOUTS.LAYOUT_WIDE.heightIn,\n})\n\n/* ────────────────────────────────────────────────────────────────────────────\n * Package layer\n *\n * Thin conveniences over `OpcPackage`, kept because this surface speaks zip\n * paths (`ppt/slides/slide1.xml`) while OPC speaks partnames (`/ppt/...`), and\n * because reaching a part's bytes is the one thing a caller of a *flat* surface\n * still routinely needs.\n * ──────────────────────────────────────────────────────────────────────────── */\n\n/**\n * Load a `.pptx` as an {@link OpcPackage} — the same package model `ts-pptx/read`\n * uses, so a caller that starts here can hand the result straight to\n * `Presentation.fromPackage()` without re-reading the bytes.\n *\n * The input must be a real OPC package: a zip that merely contains some slide XML\n * but no `[Content_Types].xml` is rejected with a `PackageReadError`.\n */\nexport async function loadPptxPackage(input: PptxInspectInput): Promise<OpcPackage> {\n\treturn OpcPackage.load(await input)\n}\n\n/** Every part in the package, as zip paths (`ppt/slides/slide1.xml`), sorted. */\nexport function listPptxParts(pptxPackage: OpcPackage): string[] {\n\treturn [...pptxPackage.parts.keys()].map(zipPathOf).sort()\n}\n\n/** Read a package part as UTF-8 text, or `null` when the part is absent. */\nexport async function readPptxTextPart(pptxPackage: OpcPackage, path: string): Promise<string | null> {\n\tconst bytes = await readPptxBinaryPart(pptxPackage, path)\n\treturn bytes ? textDecoder.decode(bytes) : null\n}\n\n/**\n * Read a package part as raw bytes — the binary sibling of {@link readPptxTextPart}\n * for embedded media (SVG/PNG/EMF blobs, fonts, …) that must not be UTF-8 decoded.\n * Returns `null` when the part is absent. The `Uint8Array` is browser-isomorphic;\n * Node consumers can wrap it with `Buffer.from(...)` if they need Buffer methods.\n */\nexport async function readPptxBinaryPart(pptxPackage: OpcPackage, path: string): Promise<Uint8Array | null> {\n\treturn pptxPackage.part(partNameOf(path))?.bytes ?? null\n}\n\nconst textDecoder = new TextDecoder('utf-8')\n\n/** OPC partnames are absolute (`/ppt/…`); this surface speaks zip paths (`ppt/…`). */\nfunction zipPathOf(partName: string): string {\n\treturn partName.startsWith('/') ? partName.slice(1) : partName\n}\n\nfunction partNameOf(zipPath: string): string {\n\treturn zipPath.startsWith('/') ? zipPath : `/${zipPath}`\n}\n\n/* ────────────────────────────────────────────────────────────────────────────\n * The surface\n * ──────────────────────────────────────────────────────────────────────────── */\n\nexport async function inspectPptx(input: PptxInspectInput): Promise<PptxInspection> {\n\tconst pptxPackage = await loadPptxPackage(input)\n\tconst slideSize = await readPresentationSize(pptxPackage)\n\tconst slides = await extractSlides(pptxPackage, slideSize)\n\treturn { slideSize, slides }\n}\n\nexport async function readPresentationSize(\n\tpptxPackage: OpcPackage,\n\tfallback: PptxSlideSize = DEFAULT_INSPECT_SLIDE_SIZE\n): Promise<PptxSlideSize> {\n\tconst size = presentationOf(pptxPackage)?.slideSize\n\tif (!size) return fallback\n\treturn { widthIn: round(size.widthIn, 3), heightIn: round(size.heightIn, 3) }\n}\n\n/**\n * Every slide in the deck, in **presentation order** (`p:sldIdLst`) — the order\n * PowerPoint shows them in, which is not the order their parts are named once a\n * deck has been reordered.\n */\nexport async function extractSlides(pptxPackage: OpcPackage, size?: PptxSlideSize): Promise<PptxSlideInspection[]> {\n\tconst slideSize = size || (await readPresentationSize(pptxPackage))\n\tconst presentation = presentationOf(pptxPackage)\n\tif (!presentation) return []\n\n\treturn presentation.slides.map((slide, index) => {\n\t\tconst path = zipPathOf(slide.partName)\n\t\tconst harvested: HarvestedShape[] = []\n\t\tharvest(slide.shapes, null, harvested) // slide level: no enclosing group\n\t\tconst elements = flatten(harvested, path)\n\t\tconst text = elements\n\t\t\t.map((el) => el.text)\n\t\t\t.filter(Boolean)\n\t\t\t.join(' ')\n\n\t\treturn {\n\t\t\tindex,\n\t\t\tname: slide.name || `Slide ${index + 1}`,\n\t\t\tpath,\n\t\t\tsize: slideSize,\n\t\t\telements,\n\t\t\ttext,\n\t\t\twordCount: countWords(text),\n\t\t}\n\t})\n}\n\n/**\n * The deck's `Presentation`, or `null` when the package holds no readable\n * `presentation.xml`. Callers here are auditing files they did not author, so a\n * package that is a valid OPC container but not a presentation reports an empty\n * deck rather than throwing. `presentationPart` is the throw site: it rejects a\n * package with no — or more than one — office-document relationship.\n */\nfunction presentationOf(pptxPackage: OpcPackage): Presentation | null {\n\tconst presentation = Presentation.fromPackage(pptxPackage)\n\ttry {\n\t\treturn presentation.presentationPart.isXmlPart ? presentation : null\n\t} catch {\n\t\treturn null\n\t}\n}\n\nexport function overlapArea(a: PptxBox, b: PptxBox): number {\n\tconst x = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x))\n\tconst y = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y))\n\treturn x * y\n}\n\nexport function boxAnchor(box: PptxBox, anchor: PptxBoxAnchor, axis: PptxBoxAxis): number {\n\tif (axis === 'x') {\n\t\tif (anchor === 'left') return box.x\n\t\tif (anchor === 'right') return box.x + box.w\n\t\treturn box.x + box.w / 2\n\t}\n\tif (anchor === 'top') return box.y\n\tif (anchor === 'bottom') return box.y + box.h\n\treturn box.y + box.h / 2\n}\n\n/* ────────────────────────────────────────────────────────────────────────────\n * Shape-tree harvest\n * ──────────────────────────────────────────────────────────────────────────── */\n\n/** One harvested shape, before it is flattened into a {@link PptxSlideElement}. */\ninterface HarvestedShape {\n\tshape: AnyShape\n\tparentZIndex: number | null\n\tchildZIndices: number[]\n}\n\n/**\n * Flatten a shape list depth-first in document order: each shape is followed by\n * its descendants, which is both paint order and the order the\n * {@link PptxSlideElement.zIndex} contract promises. Every entry's index in `out`\n * is its zIndex. Returns the zIndices assigned at this level, which is what the\n * enclosing group records as its {@link PptxSlideElement.childZIndices}.\n */\nfunction harvest(shapes: AnyShape[], parentZIndex: number | null, out: HarvestedShape[]): number[] {\n\tconst zIndices: number[] = []\n\tfor (const shape of shapes) {\n\t\tconst entry: HarvestedShape = { shape, parentZIndex, childZIndices: [] }\n\t\tconst zIndex = out.push(entry) - 1\n\t\tzIndices.push(zIndex)\n\t\tif (shape.shapeType === 'group') entry.childZIndices = harvest(shape.shapes, zIndex, out)\n\t}\n\treturn zIndices\n}\n\n/**\n * Turn harvested shapes into elements, dropping the ones with no resolvable slide\n * position. A dropped shape keeps its zIndex — the numbers are positions in the\n * shape tree, and renumbering them would silently repoint every `parentZIndex`.\n */\nfunction flatten(harvested: HarvestedShape[], slidePath: string): PptxSlideElement[] {\n\treturn harvested\n\t\t.map((entry, zIndex) => toElement(entry, zIndex, slidePath))\n\t\t.filter((element): element is PptxSlideElement => Boolean(element))\n}\n\nfunction toElement(entry: HarvestedShape, zIndex: number, slidePath: string): PptxSlideElement | null {\n\tconst { shape } = entry\n\tconst frame = shape.absoluteFrame\n\tif (!frame) {\n\t\treportUnresolvable(shape, zIndex, slidePath)\n\t\treturn null\n\t}\n\n\t// Only `p:sp` holds a text body, so every other kind projects as an empty frame.\n\tconst textFrame = shape.textFrame\n\tconst paragraphs = textFrame ? textFrame.paragraphs.map((p) => ({ runs: p.runs.map(toRun) })) : []\n\tconst textRuns = paragraphs.flatMap((paragraph) => paragraph.runs)\n\t// A graphic frame has no text body of its own; its text comes from the structure\n\t// it hosts, and arrives as a plain string with no runs behind it.\n\tconst runText = textRuns.map((run) => run.text).join('')\n\tconst raw = shape.shapeType === 'graphicFrame' ? graphicFrameText(shape) : runText\n\t// Deliberately not `TextFrame.text`: this is one whitespace-collapsed line for\n\t// matching and word-counting, not the frame's text with its line structure.\n\tconst text = raw.replace(/\\s+/g, ' ').trim()\n\tconst kind: PptxSlideElementKind =\n\t\tshape.shapeType === 'group'\n\t\t\t? 'group'\n\t\t\t: shape.shapeType === 'graphicFrame'\n\t\t\t\t? 'graphicFrame'\n\t\t\t\t: text\n\t\t\t\t\t? 'text'\n\t\t\t\t\t: shape.shapeType === 'picture'\n\t\t\t\t\t\t? 'image'\n\t\t\t\t\t\t: 'shape'\n\n\treturn {\n\t\tid: shape.id ?? zIndex + 1,\n\t\tname: shape.name || `${kind} ${zIndex + 1}`,\n\t\tkind,\n\t\tgraphicKind: shape.shapeType === 'graphicFrame' ? graphicKindOf(shape) : null,\n\t\tzIndex,\n\t\tbox: {\n\t\t\tx: emuToInches(frame.left),\n\t\t\ty: emuToInches(frame.top),\n\t\t\tw: emuToInches(frame.width),\n\t\t\th: emuToInches(frame.height),\n\t\t},\n\t\trotation: frame.rotation,\n\t\tflipH: frame.flipH,\n\t\tflipV: frame.flipV,\n\t\tparentZIndex: entry.parentZIndex,\n\t\tchildZIndices: entry.childZIndices,\n\t\ttext,\n\t\ttextWrap: textFrame?.bodyProperties?.wrap ?? null,\n\t\tautofit: textFrame?.autofit ?? null,\n\t\tautofitFontScale: textFrame?.autofitFontScale ?? null,\n\t\tbodyInsets: readBodyInsets(textFrame),\n\t\ttextRuns,\n\t\tparagraphs,\n\t\tfontSizes: [...new Set(textRuns.map((run) => run.fontSizePt).filter((size): size is number => size !== null))],\n\t\tcolors: [...new Set(textRuns.map((run) => run.color).filter((color): color is string => Boolean(color)))],\n\t\tfill: shape.fillColor,\n\t\tline: shape.lineColor,\n\t\tshapeType: shape.presetGeometry,\n\t}\n}\n\n/**\n * What a graphic frame hosts, from the same `a:graphicData/@uri` the read model's\n * `has*` predicates compare against. A frame that answers none of them is `'other'`\n * rather than dropped: a box the deck's author placed is on the slide whether or not\n * this library models its payload, and an overlap or coverage check that skipped it\n * would report a gap where a 3D model or an OLE object sits.\n */\nfunction graphicKindOf(frame: GraphicFrame): PptxGraphicKind {\n\tif (frame.hasTable) return 'table'\n\tif (frame.hasChart) return 'chart'\n\tif (frame.hasChartEx) return 'chartEx'\n\tif (frame.hasDiagram) return 'diagram'\n\treturn 'other'\n}\n\n/**\n * The text a graphic frame puts on the slide: table cells in row order, or SmartArt\n * node text. Charts contribute nothing, matching `Slide.text` on the read model — a\n * chart's strings are data labels and axis titles that PowerPoint itself does not\n * treat as slide body text.\n *\n * Separators are single spaces rather than the read model's `\t`/`\n`, because the\n * caller collapses whitespace anyway; the point here is only that cells do not run\n * together into one word.\n */\nfunction graphicFrameText(frame: GraphicFrame): string {\n\tconst table = frame.table\n\tif (table) return table.rows.map((row) => row.cells.map((cell) => cell.text).join(' ')).join(' ')\n\treturn frame.diagram?.text ?? ''\n}\n\n/** Project one read-model {@link Run} onto the flat run shape. */\nfunction toRun(run: Run): PptxTextRun {\n\treturn {\n\t\ttext: run.text,\n\t\tfontSizePt: run.fontSizePt,\n\t\tcolor: run.color,\n\t\tfontFace: run.fontName,\n\t\t// The read model distinguishes \"explicitly not bold\" from \"unset, inherits\";\n\t\t// this surface reports what renders, so an unset flag is `false`.\n\t\tbold: run.bold ?? false,\n\t\titalic: run.italic ?? false,\n\t\tstrike: run.strike,\n\t\thighlight: run.highlight?.hex ?? null,\n\t\tcharSpacingPt: run.charSpacingPt,\n\t}\n}\n\n// PowerPoint body-inset defaults (ECMA-376 §21.1.2.1.1 prose; the XSD leaves\n// lIns/tIns/rIns/bIns optional with no schema default): 0.1in left/right,\n// 0.05in top/bottom. The read model reports only the explicitly-set sides.\nconst DEFAULT_INSET_LR_IN = 0.1\nconst DEFAULT_INSET_TB_IN = 0.05\nconst POINTS_PER_INCH = 72\n\nfunction readBodyInsets(textFrame: TextFrame | null): PptxBodyInsets | null {\n\tconst insets = textFrame?.bodyProperties?.insetsPt\n\tif (!insets) return null\n\tconst inches = (pt: number | undefined, fallback: number): number =>\n\t\tpt === undefined ? fallback : pt / POINTS_PER_INCH\n\treturn {\n\t\tleft: inches(insets.left, DEFAULT_INSET_LR_IN),\n\t\ttop: inches(insets.top, DEFAULT_INSET_TB_IN),\n\t\tright: inches(insets.right, DEFAULT_INSET_LR_IN),\n\t\tbottom: inches(insets.bottom, DEFAULT_INSET_TB_IN),\n\t}\n}\n\n/* ────────────────────────────────────────────────────────────────────────────\n * Unresolvable positions\n *\n * `absoluteFrame` reports `null` for three different situations, and only two of\n * them are worth telling the caller about. The distinction is not recoverable\n * from the `null`, so it is re-derived here from the same ancestry the read model\n * walks.\n * ──────────────────────────────────────────────────────────────────────────── */\n\n/** Warn about a shape whose slide position cannot be resolved, unless it never claimed one. */\nfunction reportUnresolvable(shape: AnyShape, zIndex: number, slidePath: string): void {\n\tconst element = shape.element_\n\t// No own `a:xfrm` at all: the shape inherits its geometry from a layout\n\t// placeholder, which this surface deliberately does not resolve. Nothing is\n\t// wrong with the deck, so nothing is reported.\n\tif (!hasBox(ownTransform(element), 'a:off', 'a:ext')) return\n\n\tconst who = shape.name ? `\"${shape.name}\"` : `the element at zIndex ${zIndex}`\n\tif (enclosingGroupLacksTransform(element)) {\n\t\twarn(\n\t\t\t'inspect/group-transform-missing',\n\t\t\t`inspect: skipped ${who} on ${slidePath} — an enclosing group has no usable a:xfrm, so its slide position cannot be resolved.`\n\t\t)\n\t\treturn\n\t}\n\twarn(\n\t\t'inspect/group-transform-degenerate',\n\t\t`inspect: skipped ${who} on ${slidePath} — an enclosing group has a degenerate transform (zero a:chExt), so its slide position cannot be resolved.`\n\t)\n}\n\n/** The element's own `a:xfrm` — on `p:grpSpPr` for a group, `p:spPr` for every other kind. */\nfunction ownTransform(element: Element): Element | null {\n\tconst props = firstChild(element, element.localName === 'grpSp' ? 'p:grpSpPr' : 'p:spPr')\n\treturn props && firstChild(props, 'a:xfrm')\n}\n\n/** Whether any enclosing `p:grpSp` fails to state a complete child-space mapping. */\nfunction enclosingGroupLacksTransform(element: Element): boolean {\n\tfor (let node = element.parentNode; node && node.nodeType === ELEMENT_NODE; node = node.parentNode) {\n\t\tconst parent = node as Element\n\t\tif (parent.namespaceURI !== OOXML_NS.p || parent.localName !== 'grpSp') return false // reached the shape tree\n\t\tconst xfrm = ownTransform(parent)\n\t\tif (!hasBox(xfrm, 'a:off', 'a:ext') || !hasBox(xfrm, 'a:chOff', 'a:chExt')) return true\n\t}\n\treturn false\n}\n\n/** Whether a transform states a complete position + extent pair. */\nfunction hasBox(xfrm: Element | null, offName: string, extName: string): boolean {\n\tif (!xfrm) return false\n\tconst off = firstChild(xfrm, offName)\n\tconst ext = firstChild(xfrm, extName)\n\tif (!off || !ext) return false\n\treturn (\n\t\tintValue(attr(off, 'x')) !== null &&\n\t\tintValue(attr(off, 'y')) !== null &&\n\t\tintValue(attr(ext, 'cx')) !== null &&\n\t\tintValue(attr(ext, 'cy')) !== null\n\t)\n}\n\nfunction countWords(text: string): number {\n\treturn text.split(/\\s+/).filter(Boolean).length\n}\n\nfunction round(value: number, digits: number): number {\n\tconst factor = 10 ** digits\n\treturn Math.round(value * factor) / factor\n}\n\n// Error taxonomy — see `entry-errors.ts`. Re-exported from every entry so `instanceof`\n// works whichever subpath a consumer imports.\nexport * from './entry-errors.js'\n"],"mappings":"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"}

package/dist/math.d.ts

@@ -0,0 +1,37 @@
+import { a as TsPptxError, d as InvalidOptionErrorCode, f as MediaErrorCode, h as UnsupportedFeatureErrorCode, i as PackageReadError, l as ErrorCode, m as TsPptxCode, n as InvalidOptionError, o as TsPptxErrorOptions, p as PackageReadErrorCode, r as MediaError, s as UnsupportedFeatureError, t as InternalError, u as InternalErrorCode } from "./errors-PflMPWBn.js";
+//#region src/math.d.ts
+/**
+ * Convert a MathML string to OMML for the `math:` option on `addText`.
+ *
+ * Canonical output form: a bare `<m:oMath>…</m:oMath>` in the `m:` namespace, with no
+ * namespace declarations (the `math:` option's envelope supplies the `m` prefix).
+ *
+ * @param mathml - a MathML string (e.g. `<math>…</math>`)
+ * @returns OMML `<m:oMath>…</m:oMath>`
+ */
+declare function mathmlToOmml(mathml: string): string;
+interface LatexToOmmlOptions {
+  /**
+   * Display (block) math: render in `displayMode` and wrap the result in
+   * `<m:oMathPara>` (a centered display-math paragraph). Default `true`. When `false`,
+   * temml renders in inline mode and the result is a bare `<m:oMath>`.
+   */
+  display?: boolean;
+}
+/**
+ * Convert a LaTeX string to OMML for the `math:` option on `addText`.
+ *
+ * Display math (the default) is returned as a full `<m:oMathPara>` centered display
+ * paragraph; with `{ display: false }` a bare `<m:oMath>` is returned (both forms are
+ * accepted by the `math:` option). Throws on invalid LaTeX, surfacing temml's parse
+ * position.
+ *
+ * @param latex - a LaTeX math expression, e.g. `x = \frac{-b \pm \sqrt{b^2-4ac}}{2a}`
+ * @param opts - see {@link LatexToOmmlOptions}
+ * @returns OMML `<m:oMathPara>…</m:oMathPara>` (display) or `<m:oMath>…</m:oMath>` (inline)
+ * @throws {Error} if the LaTeX cannot be parsed
+ */
+declare function latexToOmml(latex: string, opts?: LatexToOmmlOptions): string;
+//#endregion
+export { type ErrorCode, InternalError, type InternalErrorCode, InvalidOptionError, type InvalidOptionErrorCode, LatexToOmmlOptions, MediaError, type MediaErrorCode, PackageReadError, type PackageReadErrorCode, type TsPptxCode, TsPptxError, type TsPptxErrorOptions, UnsupportedFeatureError, type UnsupportedFeatureErrorCode, latexToOmml, mathmlToOmml };
+//# sourceMappingURL=math.d.ts.map

package/dist/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","names":[],"sources":["../src/math.ts"],"mappings":";;;;;;;;;;;iBAwMgB,aAAa;UAKZ;;;;;;EAMhB;;;;;;;;;;;;;;;iBAgBe,YAAY,eAAe,OAAM"}

package/dist/math.js

@@ -0,0 +1,203 @@
+import { a as TsPptxError, i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError, t as InternalError } from "./errors-Bvln0H-7.js";
+import { createRequire } from "node:module";
+//#region src/math.ts
+/**
+* `@shbernal/ts-pptx/math` — author display equations in LaTeX or MathML and get
+* OMML for the `math:` option on `addText` (see {@link TextProps.math}).
+*
+* Pipeline: LaTeX --temml--> MathML --mathml2omml--> OMML.
+*
+* Both converters are **optional peer dependencies** (temml is MIT, mathml2omml is
+* LGPL-3.0-or-later); install them to use this subpath:
+*
+* ```sh
+* npm install temml mathml2omml
+* ```
+*
+* This subpath is **Node-only**: it loads the converters synchronously via
+* `node:module`'s `createRequire`, so `latexToOmml()` / `mathmlToOmml()` stay
+* synchronous. Both display and inline (in-sentence) equations are supported: a
+* default `latexToOmml()` returns a centered display `<m:oMathPara>`, while
+* `latexToOmml(tex, { display: false })` (and `mathmlToOmml()`) return the bare
+* `<m:oMath>` form you pass to a text item with `inline: true` to flow it
+* mid-paragraph (see {@link TextProps.inline}).
+*
+* @module
+*/
+const nodeRequire = createRequire(import.meta.url);
+const MISSING_DEPS_MESSAGE = "@shbernal/ts-pptx/math requires the optional peer dependencies 'temml' and 'mathml2omml'. Install them with: npm install temml mathml2omml";
+/** Require an optional peer, remapping a not-found error to the install hint. */
+function requirePeer(id) {
+	try {
+		return nodeRequire(id);
+	} catch (err) {
+		if (err?.code === "MODULE_NOT_FOUND") throw new UnsupportedFeatureError("math/missing-optional-peer", MISSING_DEPS_MESSAGE, { cause: err });
+		throw err;
+	}
+}
+let temmlModule;
+let mml2ommlFn;
+function loadTemml() {
+	if (!temmlModule) {
+		const mod = requirePeer("temml");
+		temmlModule = "renderToString" in mod ? mod : mod.default;
+	}
+	return temmlModule;
+}
+function loadMml2omml() {
+	if (!mml2ommlFn) mml2ommlFn = requirePeer("mathml2omml").mml2omml;
+	return mml2ommlFn;
+}
+/**
+* mathml2omml puts namespace declarations on the `<m:oMath>` opening tag: `xmlns:m`
+* (redundant — the `<a14:m>` envelope the `math:` option authors already declares it)
+* and `xmlns:w` (unused in the output it produces). Strip them so the result is a bare
+* `<m:oMath>` that drops into the `math:` option cleanly.
+*/
+function stripOMathNamespaces(omml) {
+	return omml.replace(/^(\s*<m:oMath)\b[^>]*>/, "$1>");
+}
+/** Centered-display paragraph props, matching what the `math:` emitter/oracle author. */
+const DISPLAY_PARA_PR = "<m:oMathParaPr><m:jc m:val=\"centerGroup\"/></m:oMathParaPr>";
+/**
+* The operator-dictionary subset this module has to carry, keyed by the character temml
+* puts in the `<mo>` of an accent and valued by the combining mark OMML wants in `m:chr`.
+*
+* Two halves of one problem. **Which** `<mover>`s are accents: temml renders every accent
+* command as a bare `<mover>` with no `accent="true"`, which is correct for a browser —
+* MathML renderers derive accent positioning from the operator dictionary, so the attribute
+* is redundant there — but mathml2omml has no dictionary and keys strictly off the
+* attribute, mapping a bare `<mover>` to `<m:limUpp>` (an over-*limit*, with limit spacing)
+* instead of `<m:acc>`. Membership in this table is the dictionary lookup that is otherwise
+* missing. **Which character** to attach: mathml2omml passes the `<mo>` text straight
+* through to `m:chr`, and temml emits the *spacing* modifiers (U+02C6 MODIFIER LETTER
+* CIRCUMFLEX, U+2192 RIGHTWARDS ARROW) while ECMA-376 §22.1.2.20 says an `accPr` character
+* "should be within the range of (U+0300–U+036F) or (U+20D0–U+20EF)" — the combining marks,
+* which is also what Word itself writes. Left alone, `\vec{v}` would hang a full-size arrow
+* over the base instead of an arrow accent.
+*
+* Keyed by character rather than by LaTeX command because that is all that survives into
+* the MathML. Derived by rendering every accent command temml documents and reading back
+* the `<mo>` it produced; the commands each entry serves are named in the comments.
+*/
+const ACCENT_CHARS = /* @__PURE__ */ new Map([
+	["ˆ", "̂"],
+	["~", "̃"],
+	["´", "́"],
+	["ˊ", "́"],
+	["`", "̀"],
+	["ˋ", "̀"],
+	["¨", "̈"],
+	["˙", "̇"],
+	["‾", "̄"],
+	["ˉ", "̄"],
+	["˘", "̆"],
+	["ˇ", "̌"],
+	["˚", "̊"],
+	["˝", "̋"],
+	["→", "⃗"],
+	["…", "⃛"]
+]);
+/** An `<mover>`'s last child, when that child is an `<mo>`: `[, attributes, text]`. */
+const TRAILING_MO = /<mo\b([^>]*)>([^<]*)<\/mo>\s*$/;
+/**
+* Stamp `accent="true"` on the `<mover>`s that are accents, and swap their operator for the
+* combining mark OMML wants. See {@link ACCENT_CHARS} for why both are needed.
+*
+* Scoped as narrowly as the defect. Only `<mo stretchy="false">` qualifies, which is how
+* temml distinguishes a true accent from a *wide* one (`\widehat`, `\overrightarrow`) or a
+* group character (`\overbrace`, `\overgroup`) — those already reach `m:groupChr`, which is
+* a reasonable rendering, so they are left alone rather than churned. `\stackrel` is an
+* over-relation whose character comes from the caller, so it stays `m:limUpp` unless the
+* caller happened to stack a diacritic. An `<mover>` that already states `accent` is the
+* author's call and is never rewritten.
+*
+* `<munder>` is deliberately **not** touched. The symmetric-looking fix — stamping
+* `accentunder="true"` — makes mathml2omml emit `<m:acc>`, which is an *over*-accent: it
+* would move `\utilde`'s tilde above the base. OMML has no under-accent object, so the
+* `m:limLow` an under-accent already produces is the closest thing available.
+*
+* Implemented against the tag text rather than through a DOM. temml's output is
+* machine-generated and well-formed, so pairing `<mover>` with `</mover>` on a stack is
+* exact, and this subpath otherwise carries no XML parser — the read path's is a different
+* dependency and pulling it in here would grow the module for one rewrite.
+*/
+function markAccentedMovers(mathml) {
+	const edits = [];
+	const open = [];
+	const tags = /<(\/?)mover\b[^>]*>/g;
+	for (let tag = tags.exec(mathml); tag !== null; tag = tags.exec(mathml)) {
+		if (tag[1] === "") {
+			open.push(tag[0].includes("accent=") ? -1 : tag.index);
+			continue;
+		}
+		const openAt = open.pop();
+		if (openAt === void 0 || openAt === -1) continue;
+		const openEnd = mathml.indexOf(">", openAt) + 1;
+		const mo = TRAILING_MO.exec(mathml.slice(openEnd, tag.index));
+		if (!mo) continue;
+		const [whole, attrs = "", operator = ""] = mo;
+		if (!attrs.includes("stretchy=\"false\"")) continue;
+		const combining = ACCENT_CHARS.get(operator);
+		if (combining === void 0) continue;
+		edits.push({
+			at: openEnd + mo.index + whole.length - `${operator}</mo>`.length,
+			length: operator.length,
+			text: combining
+		});
+		edits.push({
+			at: openAt + 6,
+			length: 0,
+			text: " accent=\"true\""
+		});
+	}
+	let out = mathml;
+	for (const edit of edits.sort((a, b) => b.at - a.at)) out = out.slice(0, edit.at) + edit.text + out.slice(edit.at + edit.length);
+	return out;
+}
+/**
+* Convert a MathML string to OMML for the `math:` option on `addText`.
+*
+* Canonical output form: a bare `<m:oMath>…</m:oMath>` in the `m:` namespace, with no
+* namespace declarations (the `math:` option's envelope supplies the `m` prefix).
+*
+* @param mathml - a MathML string (e.g. `<math>…</math>`)
+* @returns OMML `<m:oMath>…</m:oMath>`
+*/
+function mathmlToOmml(mathml) {
+	return stripOMathNamespaces(loadMml2omml()(mathml).trim());
+}
+/**
+* Convert a LaTeX string to OMML for the `math:` option on `addText`.
+*
+* Display math (the default) is returned as a full `<m:oMathPara>` centered display
+* paragraph; with `{ display: false }` a bare `<m:oMath>` is returned (both forms are
+* accepted by the `math:` option). Throws on invalid LaTeX, surfacing temml's parse
+* position.
+*
+* @param latex - a LaTeX math expression, e.g. `x = \frac{-b \pm \sqrt{b^2-4ac}}{2a}`
+* @param opts - see {@link LatexToOmmlOptions}
+* @returns OMML `<m:oMathPara>…</m:oMathPara>` (display) or `<m:oMath>…</m:oMath>` (inline)
+* @throws {Error} if the LaTeX cannot be parsed
+*/
+function latexToOmml(latex, opts = {}) {
+	const display = opts.display ?? true;
+	const temml = loadTemml();
+	let mathml;
+	try {
+		mathml = temml.renderToString(latex, {
+			displayMode: display,
+			throwOnError: true
+		});
+	} catch (err) {
+		const pe = err;
+		const pos = typeof pe.position === "number" ? ` (position ${pe.position})` : "";
+		throw new InvalidOptionError("math/invalid-latex", `Invalid LaTeX${pos}: ${pe.message}`, { cause: err });
+	}
+	const oMath = mathmlToOmml(markAccentedMovers(mathml));
+	return display ? `<m:oMathPara>${DISPLAY_PARA_PR}${oMath}</m:oMathPara>` : oMath;
+}
+//#endregion
+export { InternalError, InvalidOptionError, MediaError, PackageReadError, TsPptxError, UnsupportedFeatureError, latexToOmml, mathmlToOmml };
+
+//# sourceMappingURL=math.js.map