@shbernal/ts-pptx 0.0.1

package/dist/index.js

@@ -0,0 +1,75 @@
+import { t as setDiagnosticHandler } from "./diagnostics-DYQC7xLV.js";
+import { a as TsPptxError, i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError, t as InternalError } from "./errors-DGE9zh3U.js";
+import { _ as pointsToEmu, a as FIXED_PCT_PER_PERCENT, c as POINTS_PER_INCH, d as emuToInches, f as emuToPixels, g as pixelsToEmu, h as percentToEmu, i as EMU_PER_POINT, l as STANDARD_LAYOUTS, m as inchesToEmu, n as DEFAULT_PX_PER_INCH, o as HUNDREDTHS_PER_POINT, p as emuToPoints, r as EMU_PER_INCH, s as PERCENT_SCALE, t as ANGLE_UNITS_PER_DEGREE, u as coordToEmu, v as ptToHundredths } from "./units-B-JUKwCS.js";
+import { n as textRuns, r as PresentationCore, t as textRun } from "./text-WRUbOy2r.js";
+import { $ as connectorPresetFor, B as AlignV, G as PlaceholderType, H as CONNECTOR_PRESETS, J as SlideObjectType, K as SchemeColor, Q as asChartType, U as ChartType, V as BulletType, W as OutputType, X as TextAnchor, Y as TableStyle, Z as VALID_SHAPE_PRESETS, et as isChartExType, j as IMG_SVG_PLACEHOLDER, q as ShapeType, z as AlignH } from "./units-internal-7JcMfYti.js";
+import { i as bytesToBase64 } from "./image-size-C5Z1sKof.js";
+//#region src/runtime/neutral.ts
+/**
+* The adapter for a runtime that is neither Node nor a browser — Deno, Bun, an edge worker,
+* anything that imports the bare `@shbernal/ts-pptx` specifier without resolving the `node` or
+* `browser` export condition.
+*
+* It implements everything that is genuinely host-neutral and refuses only what is not.
+* `fetch`, `btoa` and `TextEncoder` exist in all of these runtimes, so remote media and fonts
+* load here exactly as they do in a browser. What is missing is a *destination*: there is no
+* `node:fs` to write to and no `document` to hand a download to, so {@link RuntimeAdapter.writeFile}
+* throws a named error rather than guessing. Everything that returns bytes to the caller —
+* `write`, `stream`, `toParts` — works normally, which is the shape that suits a worker anyway.
+*/
+function createNeutralRuntime() {
+	return {
+		writeFileOutputType: null,
+		loadMedia,
+		createSvgPngPreview,
+		writeFile,
+		loadFontData
+	};
+}
+async function loadFontData(source) {
+	const response = await fetch(source);
+	if (!response.ok) throw new MediaError("font/fetch-failed", `Unable to load font (fetch): ${source}`);
+	return new Uint8Array(await response.arrayBuffer());
+}
+/**
+* Fetch-only: a bare filesystem path has no meaning without a filesystem, and `fetch` rejecting
+* it is reported by the caller as a load failure naming the path. Returns raw base64 rather than
+* a data URI (the browser adapter's `FileReader` shape) because there is no `FileReader` here;
+* package assembly accepts either form.
+*/
+async function loadMedia(rel) {
+	const response = await fetch(rel.path);
+	if (!response.ok) throw new MediaError("media/fetch-failed", `Unable to load image (fetch): ${rel.path}`);
+	return bytesToBase64(new Uint8Array(await response.arrayBuffer()));
+}
+/** Rasterizing an SVG needs a canvas. Same fallback as Node: emit the placeholder PNG. */
+async function createSvgPngPreview(rel) {
+	rel.data = IMG_SVG_PLACEHOLDER;
+	return "done";
+}
+async function writeFile(fileName) {
+	throw new UnsupportedFeatureError("runtime/file-output-unavailable", `Cannot write "${fileName}": this runtime has neither a filesystem nor a DOM. Import "@shbernal/ts-pptx/node" to write to disk or "@shbernal/ts-pptx/browser" to trigger a download; anywhere else, use write() and persist the bytes yourself.`);
+}
+//#endregion
+//#region src/index.ts
+/**
+* The runtime-agnostic entry: what a consumer gets from the bare `@shbernal/ts-pptx` specifier
+* when neither the `node` nor the `browser` export condition resolves — Deno, Bun, edge workers.
+* Node and browser consumers reach `ts-pptx/node` and `ts-pptx/browser` through those conditions
+* without naming them, and get the same class backed by an adapter that can reach their host.
+*
+* Authoring is identical on all three. The difference is only where the finished deck can go:
+* `write`, `stream` and `toParts` hand the bytes back here as everywhere, while `writeFile`
+* throws `runtime/file-output-unavailable` because there is no filesystem and no DOM to write
+* to. Live-DOM `tableToSlides` is likewise absent — it is defined on the browser entry, and the
+* DOM-agnostic form is the free `tableToSlides` on `ts-pptx/html`.
+*/
+var TsPptx = class extends PresentationCore {
+	constructor() {
+		super(createNeutralRuntime());
+	}
+};
+//#endregion
+export { ANGLE_UNITS_PER_DEGREE, AlignH, AlignV, BulletType, CONNECTOR_PRESETS, ChartType, DEFAULT_PX_PER_INCH, EMU_PER_INCH, EMU_PER_POINT, FIXED_PCT_PER_PERCENT, HUNDREDTHS_PER_POINT, InternalError, InvalidOptionError, MediaError, OutputType, PERCENT_SCALE, POINTS_PER_INCH, PackageReadError, PlaceholderType, STANDARD_LAYOUTS, SchemeColor, ShapeType, SlideObjectType, TableStyle, TextAnchor, TsPptx, TsPptx as default, TsPptxError, UnsupportedFeatureError, VALID_SHAPE_PRESETS, asChartType, connectorPresetFor, coordToEmu, emuToInches, emuToPixels, emuToPoints, inchesToEmu, isChartExType, percentToEmu, pixelsToEmu, pointsToEmu, ptToHundredths, setDiagnosticHandler, textRun, textRuns };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/runtime/neutral.ts","../src/index.ts"],"sourcesContent":["import { IMG_SVG_PLACEHOLDER } from '../constants-internal.js'\nimport { MediaError, UnsupportedFeatureError } from '../errors.js'\nimport { bytesToBase64 } from '../media/base64.js'\nimport type { SlideRelMedia } from '../types/internal.js'\nimport type { RuntimeAdapter } from './types.js'\n\n/**\n * The adapter for a runtime that is neither Node nor a browser — Deno, Bun, an edge worker,\n * anything that imports the bare `@shbernal/ts-pptx` specifier without resolving the `node` or\n * `browser` export condition.\n *\n * It implements everything that is genuinely host-neutral and refuses only what is not.\n * `fetch`, `btoa` and `TextEncoder` exist in all of these runtimes, so remote media and fonts\n * load here exactly as they do in a browser. What is missing is a *destination*: there is no\n * `node:fs` to write to and no `document` to hand a download to, so {@link RuntimeAdapter.writeFile}\n * throws a named error rather than guessing. Everything that returns bytes to the caller —\n * `write`, `stream`, `toParts` — works normally, which is the shape that suits a worker anyway.\n */\nexport function createNeutralRuntime(): RuntimeAdapter {\n\treturn {\n\t\twriteFileOutputType: null,\n\t\tloadMedia,\n\t\tcreateSvgPngPreview,\n\t\twriteFile,\n\t\tloadFontData,\n\t}\n}\n\nasync function loadFontData(source: string): Promise<Uint8Array> {\n\tconst response = await fetch(source)\n\tif (!response.ok) throw new MediaError('font/fetch-failed', `Unable to load font (fetch): ${source}`)\n\treturn new Uint8Array(await response.arrayBuffer())\n}\n\n/**\n * Fetch-only: a bare filesystem path has no meaning without a filesystem, and `fetch` rejecting\n * it is reported by the caller as a load failure naming the path. Returns raw base64 rather than\n * a data URI (the browser adapter's `FileReader` shape) because there is no `FileReader` here;\n * package assembly accepts either form.\n */\nasync function loadMedia(rel: SlideRelMedia & { path: string }): Promise<string> {\n\tconst response = await fetch(rel.path)\n\tif (!response.ok) throw new MediaError('media/fetch-failed', `Unable to load image (fetch): ${rel.path}`)\n\treturn bytesToBase64(new Uint8Array(await response.arrayBuffer()))\n}\n\n/** Rasterizing an SVG needs a canvas. Same fallback as Node: emit the placeholder PNG. */\nasync function createSvgPngPreview(rel: SlideRelMedia): Promise<string> {\n\trel.data = IMG_SVG_PLACEHOLDER\n\treturn 'done'\n}\n\nasync function writeFile(fileName: string): Promise<string> {\n\tthrow new UnsupportedFeatureError(\n\t\t'runtime/file-output-unavailable',\n\t\t`Cannot write \"${fileName}\": this runtime has neither a filesystem nor a DOM. ` +\n\t\t\t'Import \"@shbernal/ts-pptx/node\" to write to disk or \"@shbernal/ts-pptx/browser\" to trigger a ' +\n\t\t\t'download; anywhere else, use write() and persist the bytes yourself.'\n\t)\n}\n","import PresentationCore from './presentation.js'\nimport { createNeutralRuntime } from './runtime/neutral.js'\n\n/**\n * The runtime-agnostic entry: what a consumer gets from the bare `@shbernal/ts-pptx` specifier\n * when neither the `node` nor the `browser` export condition resolves — Deno, Bun, edge workers.\n * Node and browser consumers reach `ts-pptx/node` and `ts-pptx/browser` through those conditions\n * without naming them, and get the same class backed by an adapter that can reach their host.\n *\n * Authoring is identical on all three. The difference is only where the finished deck can go:\n * `write`, `stream` and `toParts` hand the bytes back here as everywhere, while `writeFile`\n * throws `runtime/file-output-unavailable` because there is no filesystem and no DOM to write\n * to. Live-DOM `tableToSlides` is likewise absent — it is defined on the browser entry, and the\n * DOM-agnostic form is the free `tableToSlides` on `ts-pptx/html`.\n */\nexport class TsPptx extends PresentationCore {\n\tconstructor() {\n\t\tsuper(createNeutralRuntime())\n\t}\n}\n\nexport { TsPptx as default }\nexport * from './enums.js'\nexport * from './units.js'\n// Use `export *` (not `export type *`) so the value exports `textRun`/`textRuns`\n// reach this entry; `export type *` would drop them and crash any consumer that\n// imports them, while TypeScript (reading index.d.ts) stays green.\nexport * from './types/index.js'\nexport { setDiagnosticHandler, type Diagnostic, type DiagnosticCode, type DiagnosticHandler } from './diagnostics.js'\n\n// Error taxonomy — every failure the library throws. The classes and their `code` are API;\n// the message is not. Re-exported from every entry so `instanceof` works whichever subpath a\n// consumer imports — they all resolve to one shared module, so the classes are identical.\nexport {\n\tTsPptxError,\n\tInvalidOptionError,\n\tUnsupportedFeatureError,\n\tPackageReadError,\n\tMediaError,\n\tInternalError,\n\ttype TsPptxErrorOptions,\n} from './errors.js'\nexport type {\n\tErrorCode,\n\tTsPptxCode,\n\tInvalidOptionErrorCode,\n\tUnsupportedFeatureErrorCode,\n\tPackageReadErrorCode,\n\tMediaErrorCode,\n\tInternalErrorCode,\n} from './codes.js'\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,uBAAuC;CACtD,OAAO;EACN,qBAAqB;EACrB;EACA;EACA;EACA;CACD;AACD;AAEA,eAAe,aAAa,QAAqC;CAChE,MAAM,WAAW,MAAM,MAAM,MAAM;CACnC,IAAI,CAAC,SAAS,IAAI,MAAM,IAAI,WAAW,qBAAqB,gCAAgC,QAAQ;CACpG,OAAO,IAAI,WAAW,MAAM,SAAS,YAAY,CAAC;AACnD;;;;;;;AAQA,eAAe,UAAU,KAAwD;CAChF,MAAM,WAAW,MAAM,MAAM,IAAI,IAAI;CACrC,IAAI,CAAC,SAAS,IAAI,MAAM,IAAI,WAAW,sBAAsB,iCAAiC,IAAI,MAAM;CACxG,OAAO,cAAc,IAAI,WAAW,MAAM,SAAS,YAAY,CAAC,CAAC;AAClE;;AAGA,eAAe,oBAAoB,KAAqC;CACvE,IAAI,OAAO;CACX,OAAO;AACR;AAEA,eAAe,UAAU,UAAmC;CAC3D,MAAM,IAAI,wBACT,mCACA,iBAAiB,SAAS,sNAG3B;AACD;;;;;;;;;;;;;;;AC5CA,IAAa,SAAb,cAA4B,iBAAiB;CAC5C,cAAc;EACb,MAAM,qBAAqB,CAAC;CAC7B;AACD"}

package/dist/inspect.d.ts

@@ -0,0 +1,173 @@
+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-DRLpOpgQ.js";
+import { n as OpcPackage } from "./package-CaOLXSNi.js";
+//#region src/inspect.d.ts
+/**
+ * Input to the inspect surface. A `string` is a **filesystem path** (Node) read
+ * from disk; pass `Uint8Array`/`ArrayBuffer`/`Blob`/`number[]` for an in-memory
+ * archive. (A string is a path, not JSZip's latin1 binary content — see
+ * {@link ZipInput}.)
+ */
+type PptxInspectInputValue = string | number[] | Uint8Array | ArrayBuffer | Blob;
+type PptxInspectInput = PptxInspectInputValue | Promise<PptxInspectInputValue>;
+interface PptxSlideSize {
+  widthIn: number;
+  heightIn: number;
+}
+interface PptxBox {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+interface PptxTextRun {
+  text: string;
+  fontSizePt: number | null;
+  color: string | null;
+  /** Run font face (`a:rPr > a:latin@typeface`), or null when it inherits from the theme/placeholder. */
+  fontFace: string | null;
+  /** Bold (`a:rPr@b`). */
+  bold: boolean;
+  /** Italic (`a:rPr@i`). */
+  italic: boolean;
+  /** Strikethrough token (`a:rPr@strike`: `noStrike`/`sngStrike`/`dblStrike`), or null when unset. */
+  strike: string | null;
+  /** Highlight colour hex (`a:rPr > a:highlight`), or null when unset. A theme token is resolved against the slide's theme. */
+  highlight: string | null;
+  /** Character spacing in points (`a:rPr@spc`, authored in hundredths of a point), or null when unset. */
+  charSpacingPt: number | null;
+}
+/**
+ * One paragraph (`a:p`): its runs in document order. Preserves the paragraph/line
+ * boundaries that the flat {@link PptxSlideElement.textRuns} list discards — needed
+ * to measure a `wrap="none"` frame line-by-line (each paragraph is one unwrapped line).
+ */
+interface PptxParagraph {
+  runs: PptxTextRun[];
+}
+/**
+ * What an element is. `'group'` is a `p:grpSp` container: it has its own identity,
+ * box, and fill, but no text of its own — its content is the elements that name it
+ * in {@link PptxSlideElement.parentZIndex}.
+ */
+type PptxSlideElementKind = 'text' | 'image' | 'shape' | 'group';
+/**
+ * Vertical-autofit mode of a text frame, read from the `a:bodyPr` child element:
+ * - `'none'`: no autofit (`a:noAutofit`, or no autofit child at all). The box has a
+ *   fixed height the text must fit inside — a genuine overflow candidate.
+ * - `'normAutofit'`: shrink text to fit (`a:normAutofit`, ts-pptx `fit: 'shrink'`).
+ *   Text is downscaled rather than overflowing.
+ * - `'spAutoFit'`: resize shape to fit text (`a:spAutoFit`, ts-pptx `fit: 'resize'`).
+ *   The authored height is an output, not a constraint, so the box cannot overflow.
+ */
+type PptxAutofitMode = 'none' | 'normAutofit' | 'spAutoFit';
+/**
+ * Text-frame body insets in inches (`a:bodyPr` `lIns`/`tIns`/`rIns`/`bIns`), with
+ * PowerPoint defaults applied when an attribute is absent (0.1in left/right,
+ * 0.05in top/bottom). Subtract these from {@link PptxBox} to get the inner text box.
+ */
+interface PptxBodyInsets {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}
+interface PptxSlideElement {
+  id: string | number;
+  name: string;
+  kind: PptxSlideElementKind;
+  /**
+   * Paint order on the slide, `0`-based: the element's position in a depth-first
+   * walk of `p:spTree` in document order. A group is immediately followed by its
+   * own children, which is also the order PowerPoint paints them, so a higher
+   * `zIndex` draws on top. Unique within a slide, which is what
+   * {@link parentZIndex} / {@link childZIndices} key on.
+   */
+  zIndex: number;
+  /**
+   * Position and size in **slide-absolute** inches, composing every enclosing
+   * group transform — directly comparable across elements whether or not they are
+   * grouped. For a rotated element this is the unrotated placement box (the box
+   * PowerPoint writes after Ungroup); see {@link rotation}.
+   */
+  box: PptxBox;
+  /**
+   * Effective clockwise rotation in degrees, normalised to `[0, 360)`, after
+   * composing the element's own `a:xfrm@rot` with every enclosing group rotation.
+   */
+  rotation: number;
+  /** Effective horizontal flip, XOR-composing the element's own `@flipH` with enclosing group flips. */
+  flipH: boolean;
+  /** Effective vertical flip, XOR-composing the element's own `@flipV` with enclosing group flips. */
+  flipV: boolean;
+  /** {@link zIndex} of the enclosing `'group'` element, or `null` when the element sits at slide level. */
+  parentZIndex: number | null;
+  /** {@link zIndex} of each direct child, in document order. Empty unless {@link kind} is `'group'`. */
+  childZIndices: number[];
+  text: string;
+  textWrap: string | null;
+  autofit: PptxAutofitMode | null;
+  /**
+   * Baked shrink scale from `<a:normAutofit@fontScale>` as a percent (62.5 = 62.5%),
+   * or null when the frame has no `normAutofit` or bakes no scale (a bare
+   * `<a:normAutofit/>`, which PowerPoint draws at 100% until edited).
+   */
+  autofitFontScale: number | null;
+  bodyInsets: PptxBodyInsets | null;
+  textRuns: PptxTextRun[];
+  /** Runs grouped by their source paragraph (`a:p`), in document order. */
+  paragraphs: PptxParagraph[];
+  fontSizes: number[];
+  colors: string[];
+  fill: string | null;
+  line: string | null;
+  shapeType: string | null;
+}
+interface PptxSlideInspection {
+  index: number;
+  name: string;
+  path: string;
+  size: PptxSlideSize;
+  elements: PptxSlideElement[];
+  text: string;
+  wordCount: number;
+}
+interface PptxInspection {
+  slideSize: PptxSlideSize;
+  slides: PptxSlideInspection[];
+}
+type PptxBoxAxis = 'x' | 'y';
+type PptxBoxAnchor = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
+declare const DEFAULT_INSPECT_SLIDE_SIZE: PptxSlideSize;
+/**
+ * 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`.
+ */
+declare function loadPptxPackage(input: PptxInspectInput): Promise<OpcPackage>;
+/** Every part in the package, as zip paths (`ppt/slides/slide1.xml`), sorted. */
+declare function listPptxParts(pptxPackage: OpcPackage): string[];
+/** Read a package part as UTF-8 text, or `null` when the part is absent. */
+declare function readPptxTextPart(pptxPackage: OpcPackage, path: string): Promise<string | 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.
+ */
+declare function readPptxBinaryPart(pptxPackage: OpcPackage, path: string): Promise<Uint8Array | null>;
+declare function inspectPptx(input: PptxInspectInput): Promise<PptxInspection>;
+declare function readPresentationSize(pptxPackage: OpcPackage, fallback?: PptxSlideSize): Promise<PptxSlideSize>;
+/**
+ * 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.
+ */
+declare function extractSlides(pptxPackage: OpcPackage, size?: PptxSlideSize): Promise<PptxSlideInspection[]>;
+declare function overlapArea(a: PptxBox, b: PptxBox): number;
+declare function boxAnchor(box: PptxBox, anchor: PptxBoxAnchor, axis: PptxBoxAxis): number;
+//#endregion
+export { DEFAULT_INSPECT_SLIDE_SIZE, type ErrorCode, InternalError, type InternalErrorCode, InvalidOptionError, type InvalidOptionErrorCode, MediaError, type MediaErrorCode, PackageReadError, type PackageReadErrorCode, PptxAutofitMode, PptxBodyInsets, PptxBox, PptxBoxAnchor, PptxBoxAxis, PptxInspectInput, PptxInspection, PptxParagraph, PptxSlideElement, PptxSlideElementKind, PptxSlideInspection, PptxSlideSize, PptxTextRun, type TsPptxCode, TsPptxError, type TsPptxErrorOptions, UnsupportedFeatureError, type UnsupportedFeatureErrorCode, boxAnchor, extractSlides, inspectPptx, listPptxParts, loadPptxPackage, overlapArea, readPptxBinaryPart, readPptxTextPart, readPresentationSize };
+//# sourceMappingURL=inspect.d.ts.map

package/dist/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","names":[],"sources":["../src/inspect.ts"],"mappings":";;;;;;;;;KAqCK,4CAA4C,aAAa,cAAc;KAEhE,mBAAmB,wBAAwB,QAAQ;UAE9C;EAChB;EACA;;UAGgB;EAChB;EACA;EACA;EACA;;UAGgB;EAChB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;UAQgB;EAChB,MAAM;;;;;;;KAQK;;;;;;;;;;KAWA;;;;;;UAOK;EAChB;EACA;EACA;EACA;;UAGgB;EAChB;EACA;EACA,MAAM;;;;;;;;EAQN;;;;;;;EAOA,KAAK;;;;;EAKL;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA,SAAS;;;;;;EAMT;EACA,YAAY;EACZ,UAAU;;EAEV,YAAY;EACZ;EACA;EACA;EACA;EACA;;UAGgB;EAChB;EACA;EACA;EACA,MAAM;EACN,UAAU;EACV;EACA;;UAGgB;EAChB,WAAW;EACX,QAAQ;;KAGG;KACA;cAEC,4BAA4B;;;;;;;;;iBAsBnB,gBAAgB,OAAO,mBAAmB,QAAQ;;iBAKxD,cAAc,aAAa;;iBAKrB,iBAAiB,aAAa,YAAY,eAAe;;;;;;;iBAWzD,mBAAmB,aAAa,YAAY,eAAe,QAAQ;iBAmBnE,YAAY,OAAO,mBAAmB,QAAQ;iBAO9C,qBACrB,aAAa,YACb,WAAU,gBACR,QAAQ;;;;;;iBAWW,cAAc,aAAa,YAAY,OAAO,gBAAgB,QAAQ;iBA2C5E,YAAY,GAAG,SAAS,GAAG;iBAM3B,UAAU,KAAK,SAAS,QAAQ,eAAe,MAAM"}

package/dist/inspect.js

@@ -0,0 +1,285 @@
+import { n as warn } from "./diagnostics-DYQC7xLV.js";
+import { a as TsPptxError, i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError, t as InternalError } from "./errors-DGE9zh3U.js";
+import { d as emuToInches, l as STANDARD_LAYOUTS } from "./units-B-JUKwCS.js";
+import { J as OOXML_NS, Y as attr, at as intValue, et as firstChild } from "./shapes-BZU8UTW2.js";
+import { f as OpcPackage, t as Presentation } from "./presentation-B0JWdTN1.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.
+* - **No `p:graphicFrame`.** Tables, charts, and SmartArt are structures, not
+*   boxes with text, and flattening them here would report a shape whose content
+*   this surface cannot describe.
+*/
+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) {
+		if (shape.shapeType === "graphicFrame") continue;
+		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 text = textRuns.map((run) => run.text).join("").replace(/\s+/g, " ").trim();
+	const kind = shape.shapeType === "group" ? "group" : text ? "text" : shape.shapeType === "picture" ? "image" : "shape";
+	return {
+		id: shape.id ?? zIndex + 1,
+		name: shape.name || `${kind} ${zIndex + 1}`,
+		kind,
+		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
+	};
+}
+/** 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 * - **No `p:graphicFrame`.** Tables, charts, and SmartArt are structures, not\n *   boxes with text, and flattening them here would report a shape whose content\n *   this surface cannot describe.\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 { 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}.\n */\nexport type PptxSlideElementKind = 'text' | 'image' | 'shape' | 'group'\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 * 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\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\t// A `p:graphicFrame` hosts a table, chart, or SmartArt — a structure, not a box\n\t\t// with text. It is outside this surface entirely, so it does not consume a zIndex\n\t\t// either; use `ts-pptx/read` for what is inside one.\n\t\tif (shape.shapeType === 'graphicFrame') continue\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// 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 = textRuns\n\t\t.map((run) => run.text)\n\t\t.join('')\n\t\t.replace(/\\s+/g, ' ')\n\t\t.trim()\n\tconst kind: PptxSlideElementKind =\n\t\tshape.shapeType === 'group' ? 'group' : text ? 'text' : shape.shapeType === 'picture' ? 'image' : 'shape'\n\n\treturn {\n\t\tid: shape.id ?? zIndex + 1,\n\t\tname: shape.name || `${kind} ${zIndex + 1}`,\n\t\tkind,\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/** 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 — every failure the library throws. The classes and their `code` are API;\n// the message is not. Re-exported from every entry so `instanceof` works whichever subpath a\n// consumer imports — they all resolve to one shared module, so the classes are identical.\nexport {\n\tTsPptxError,\n\tInvalidOptionError,\n\tUnsupportedFeatureError,\n\tPackageReadError,\n\tMediaError,\n\tInternalError,\n\ttype TsPptxErrorOptions,\n} from './errors.js'\nexport type {\n\tErrorCode,\n\tTsPptxCode,\n\tInvalidOptionErrorCode,\n\tUnsupportedFeatureErrorCode,\n\tPackageReadErrorCode,\n\tMediaErrorCode,\n\tInternalErrorCode,\n} from './codes.js'\n"],"mappings":"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"}