ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/export/handout-master-chrome.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkFGKPZFLL_cjs = require('../chunk-FGKPZFLL.cjs');
+
+
+
+Object.defineProperty(exports, "handoutMasterChrome", {
+  enumerable: true,
+  get: function () { return chunkFGKPZFLL_cjs.handoutMasterChrome; }
+});

package/dist/pptx/export/handout-master-chrome.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Pure handout-master "chrome" descriptor: resolves the handout master's
+ * background, header/footer/date/page-number placeholder text, and (when the
+ * master defines them) the slide-image placeholder rects, into a
+ * framework-neutral shape every binding's print path can paint.
+ *
+ * PowerPoint's Print > Handouts output is not a bare N-per-page grid: it
+ * honours the handout master's background, prints its header/footer/date/
+ * page-number placeholders wherever the master's `<p:hf>` flags leave them
+ * enabled, and (rare, but legal OOXML) can size the slide cells from the
+ * master's own placeholder geometry instead of an app-computed grid. This
+ * module resolves all of that; `print-document.ts`'s `buildHandoutsHtml`
+ * paints the result into the printed page.
+ *
+ * Geometry convention: every rect is expressed as page-fraction coordinates
+ * (`0..1`), matching `master-page-layout.ts`'s `NOTES_MASTER_PLACEHOLDER_RECTS`
+ * / `computeHandoutSlotLayout` and the handout/notes master canvas editors
+ * that already draw the same four corner boxes for editing. Reusing those
+ * fractions keeps the printed chrome consistent with what the master view
+ * shows while editing.
+ */
+import type { PptxHandoutMaster } from 'ooxml-core/pptx';
+import type { MasterPageRect } from '../render/master-page-layout.js';
+/** A resolved, positioned chrome box (header/footer/date/page-number text). */
+export interface HandoutChromeBox {
+    /** Resolved plain text (field placeholders already substituted). */
+    text: string;
+    /** Page-fraction rect (`0..1`). */
+    rect: MasterPageRect;
+}
+/** Resolved background paint for the handout master. */
+export interface HandoutChromeBackground {
+    color?: string;
+    imageDataUrl?: string;
+}
+/** Per-page inputs the chrome resolution needs. */
+export interface HandoutMasterChromeOptions {
+    /** Zero-based index of this handout page within the print job. */
+    pageIndex: number;
+    /** Total handout page count in the print job. */
+    pageCount: number;
+    /** Wall-clock time stamped onto an auto (`datetime`) date field. Defaults to `new Date()`. */
+    printedAt?: Date;
+    /** BCP-47 locale for formatting the auto date. Defaults to `en-US`. */
+    locale?: string;
+}
+/** Framework-neutral handout master chrome for a single printed page. */
+export interface HandoutMasterChrome {
+    background?: HandoutChromeBackground;
+    header?: HandoutChromeBox;
+    footer?: HandoutChromeBox;
+    date?: HandoutChromeBox;
+    pageNumber?: HandoutChromeBox;
+    /**
+     * Slide-cell rects (page fractions), only when the master's own shape tree
+     * defines fully-positioned slide-image placeholders. `undefined` when it
+     * does not, so the caller keeps computing its own app grid
+     * (`computeHandoutSlotLayout`).
+     */
+    slideRects?: MasterPageRect[];
+}
+/**
+ * Resolve the handout master's chrome for a single printed page: background,
+ * header/footer/date/page-number boxes, and slide-cell rects.
+ *
+ * A part is only emitted when BOTH the master's `<p:hf>` flag for it is not
+ * `false` (spec default is "shown") AND its placeholder shape actually
+ * exists in `handoutMaster.elements` (a deck can flip the flag on with no
+ * placeholder shape to draw, in which case there is nothing to print).
+ */
+export declare function handoutMasterChrome(handoutMaster: PptxHandoutMaster | undefined, options: HandoutMasterChromeOptions): HandoutMasterChrome;
+//# sourceMappingURL=handout-master-chrome.d.ts.map

package/dist/pptx/export/handout-master-chrome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handout-master-chrome.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/handout-master-chrome.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAEX,iBAAiB,EAGjB,MAAM,iBAAiB,CAAC;AAMzB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAMnE,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAChC,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,IAAI,EAAE,cAAc,CAAC;CACrB;AAED,wDAAwD;AACxD,MAAM,WAAW,uBAAuB;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,mDAAmD;AACnD,MAAM,WAAW,0BAA0B;IAC1C,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,8FAA8F;IAC9F,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,yEAAyE;AACzE,MAAM,WAAW,mBAAmB;IACnC,UAAU,CAAC,EAAE,uBAAuB,CAAC;IACrC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;CAC9B;AAqFD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAClC,aAAa,EAAE,iBAAiB,GAAG,SAAS,EAC5C,OAAO,EAAE,0BAA0B,GACjC,mBAAmB,CAwDrB"}

package/dist/pptx/export/handout-master-chrome.mjs

@@ -0,0 +1 @@
+export { handoutMasterChrome } from '../chunk-IXFG46KB.mjs';

package/dist/pptx/export/html-escape.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var chunkUPN5FFKP_cjs = require('../chunk-UPN5FFKP.cjs');
+
+
+
+Object.defineProperty(exports, "escapeHtml", {
+  enumerable: true,
+  get: function () { return chunkUPN5FFKP_cjs.escapeHtml; }
+});
+Object.defineProperty(exports, "safeDataImageSrc", {
+  enumerable: true,
+  get: function () { return chunkUPN5FFKP_cjs.safeDataImageSrc; }
+});

package/dist/pptx/export/html-escape.d.ts

@@ -0,0 +1,23 @@
+/**
+ * HTML/text escaping shared by every print-document markup builder
+ * (`print-document.ts`, `handout-chrome-html.ts`). Split out of
+ * `print-document.ts` (which was already over this repo's 300-LOC-per-file
+ * guideline) so it can be reused without a circular import between the two.
+ *
+ * ng-packagr constraint honoured here (the Angular binding inlines this
+ * source and compiles it through ng-packagr): NO `String.prototype.replaceAll`
+ * (`escapeHtml` uses `.split(x).join(y)` instead).
+ */
+/**
+ * Escape text for safe interpolation into HTML element content / attributes.
+ * Escapes `&`, `<`, `>`, `"`, and `'`. Uses `.split().join()` rather than
+ * `replaceAll` to stay within the ng-packagr lib target.
+ */
+export declare function escapeHtml(value: string): string;
+/**
+ * Validate an `img` `src` for inclusion in the print document. Only
+ * `data:image/...` URLs pass through (escaped); anything else collapses to a
+ * transparent 1x1 PNG so the markup stays well-formed and inert.
+ */
+export declare function safeDataImageSrc(src: string): string;
+//# sourceMappingURL=html-escape.d.ts.map

package/dist/pptx/export/html-escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-escape.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/html-escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAYhD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKpD"}

package/dist/pptx/export/html-escape.mjs

@@ -0,0 +1 @@
+export { escapeHtml, safeDataImageSrc } from '../chunk-IEAO7N4E.mjs';

package/dist/pptx/export/html2canvas-clone.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkOHE5UXST_cjs = require('../chunk-OHE5UXST.cjs');
+require('../chunk-G4WRLFMJ.cjs');
+require('../chunk-HJ3JZXOL.cjs');
+
+
+
+Object.defineProperty(exports, "prepareHtml2CanvasClone", {
+  enumerable: true,
+  get: function () { return chunkOHE5UXST_cjs.prepareHtml2CanvasClone; }
+});

package/dist/pptx/export/html2canvas-clone.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Prepare html2canvas's cloned capture document.
+ *
+ * `original` is the live element handed to html2canvas; `doc` and `clonedEl`
+ * are what its `onclone` callback receives. Order matters:
+ *
+ * 1. 3D views settle on the live tree, then each cloned view is replaced by an
+ *    `<img>` of its canvas plus its DOM overlay. This runs first, while the
+ *    live and cloned trees still pair up in document order.
+ * 2. Editor-only nodes (`data-export-ignore`) are removed and the recorded
+ *    pre-selection paint is restored, exactly as the `foreignObject` path does.
+ * 3. Colours html2canvas cannot parse are normalised to sRGB.
+ * 4. CSS features html2canvas cannot paint are flattened.
+ */
+export declare function prepareHtml2CanvasClone(original: HTMLElement, doc: Document, clonedEl: HTMLElement): Promise<void>;
+//# sourceMappingURL=html2canvas-clone.d.ts.map

package/dist/pptx/export/html2canvas-clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html2canvas-clone.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/html2canvas-clone.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,uBAAuB,CAC5C,QAAQ,EAAE,WAAW,EACrB,GAAG,EAAE,QAAQ,EACb,QAAQ,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CAMf"}

package/dist/pptx/export/html2canvas-clone.mjs

@@ -0,0 +1,3 @@
+export { prepareHtml2CanvasClone } from '../chunk-C42ZL35K.mjs';
+import '../chunk-2V5ATMMB.mjs';
+import '../chunk-7JBQPQ6G.mjs';

package/dist/pptx/export/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Framework-agnostic EXPORT helpers shared by the React, Vue, and Angular
+ * `pptx-viewer` bindings. These are the PURE portions of the export pipeline  -
+ * byte/string assembly and layout math  -  with zero DOM/browser dependency. The
+ * DOM/canvas/Blob drivers (html2canvas capture, `getImageData`, object-URL
+ * creation, print-window writing) stay in each binding.
+ *
+ * - gif:      `gif-encoder` (median-cut quantisation + LZW GIF89a byte encoder,
+ *             plus pure frame-planning / dimension-clamp helpers).
+ * - handouts: `handout-layout` (slides-per-page grid, A4 page geometry, cell
+ *             positioning, pagination).
+ * - notes:    `notes-page-layout` (per-slide notes-page thumbnail + text-area
+ *             geometry in mm).
+ * - pdf:      `pdf-notes-layout` (notes-page PDF point geometry, text wrapping,
+ *             PDF content-stream fragments, escaping, layout constants).
+ * - svg:      `svg-print` (self-contained SVG / print-HTML string assembly +
+ *             XML escaping + data-URL).
+ */
+export * from './download-helpers.js';
+export * from './deck-json.js';
+export * from './canvas-jpeg.js';
+export * from './gif-encoder.js';
+export * from './export-capture-decision.js';
+export * from './handout-layout.js';
+export * from './handout-master-chrome.js';
+export * from './handout-chrome-html.js';
+export * from './html-escape.js';
+export * from './notes-page-layout.js';
+export * from './pdf-notes-layout.js';
+export * from './svg-print.js';
+export * from './css-preprocessing.js';
+export * from './canvas-color-fix.js';
+export * from './html2canvas-clone.js';
+export * from './pdf-slides.js';
+export * from './pdf-notes-builder.js';
+export * from './pdf-page-size.js';
+export * from './print-document.js';
+export * from './print-window.js';
+export * from './video-plan.js';
+export * from './png-crc32.js';
+export * from './png-chunk-builder.js';
+export * from './png-row-filter.js';
+export * from './streaming-png-encoder.js';
+export * from './rasterize-foreign-object.js';
+export * from './canvas-size-probe.js';
+export * from './rasterize-element-strategy.js';
+export * from './rasterize-element-tiles.js';
+export * from './rasterize-element.js';
+export * from './tile-row-stitch.js';
+export * from './pdf-tile-placement.js';
+export * from './rasterize-element-clamped.js';
+export * from './rasterize-element-tiled-canvas.js';
+export * from './raster-result-to-blob.js';
+export * from './save-element-as-picture.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/pptx/export/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,cAAc,oBAAoB,CAAC;AAEnC,cAAc,aAAa,CAAC;AAE5B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAG9B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AAIjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAK5B,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,qBAAqB,CAAC;AAIpC,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAIhC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,gBAAgB,CAAC;AAG/B,cAAc,cAAc,CAAC;AAI7B,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AAKxC,cAAc,4BAA4B,CAAC;AAK3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,8BAA8B,CAAC;AAI7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AAGpC,cAAc,mBAAmB,CAAC;AAIlC,cAAc,sBAAsB,CAAC;AAKrC,cAAc,6BAA6B,CAAC;AAK5C,cAAc,kCAAkC,CAAC;AAIjD,cAAc,yBAAyB,CAAC;AAGxC,cAAc,2BAA2B,CAAC"}

package/dist/pptx/export/notes-page-layout.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure notes-page layout calculations  -  shared by every binding's print path.
+ *
+ * Each notes page displays one slide thumbnail in the top half and the slide's
+ * speaker notes in the bottom half. All geometry is in A4 portrait mm; no
+ * DOM/framework dependency.
+ */
+import type { PageDimensions } from './handout-layout.js';
+/** Dimensions for the slide thumbnail area on a notes page. */
+export interface NotesPageSlideArea {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Dimensions for the notes text area on a notes page. */
+export interface NotesPageTextArea {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Layout data for a single notes page. */
+export interface NotesPageData {
+    pageIndex: number;
+    slideIndex: number;
+    slideArea: NotesPageSlideArea;
+    textArea: NotesPageTextArea;
+}
+/**
+ * Compute the layout for a single notes page.
+ *
+ * The slide thumbnail is centred horizontally in the top area, maintaining a
+ * 16:9 aspect ratio. The notes text fills the bottom.
+ */
+export declare function computeNotesPageLayout(pageIndex: number, slideIndex: number, page?: PageDimensions): NotesPageData;
+/**
+ * Compute layouts for all notes pages from the given slide indices.
+ * Each slide gets its own page (1 slide per page).
+ */
+export declare function computeAllNotesPages(slideIndices: number[]): NotesPageData[];
+/** Get the printable area dimensions for the notes page (always portrait A4). */
+export declare function getNotesPrintableArea(): {
+    width: number;
+    height: number;
+};
+//# sourceMappingURL=notes-page-layout.d.ts.map

package/dist/pptx/export/notes-page-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes-page-layout.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/notes-page-layout.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMvD,+DAA+D;AAC/D,MAAM,WAAW,kBAAkB;IAClC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,0DAA0D;AAC1D,MAAM,WAAW,iBAAiB;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,2CAA2C;AAC3C,MAAM,WAAW,aAAa;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,QAAQ,EAAE,iBAAiB,CAAC;CAC5B;AAmBD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,IAAI,GAAE,cAA4B,GAChC,aAAa,CAuCf;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,aAAa,EAAE,CAE5E;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,IAAI;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAKzE"}

package/dist/pptx/export/pdf-notes-builder.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Pure notes-page PDF byte assembly, shared by every binding's PDF export.
+ *
+ * Each page contains the slide image in the upper 2/3 and speaker notes text in
+ * the lower 1/3, following PowerPoint's "Notes Pages" print layout. If notes
+ * overflow the primary page, continuation pages are emitted with a
+ * "Slide N (continued)" header.
+ *
+ * No DOM dependency: the binding converts canvases to JPEG bytes up front and
+ * passes the compact image data plus per-slide notes here.
+ */
+import type { PdfImageData } from './pdf-notes-layout.js';
+/** Per-slide notes metadata paired by index with the slide image data. */
+export interface NotesPageMeta {
+    /** Plain-text speaker notes for this slide (may be empty/undefined). */
+    notes?: string;
+    /** One-based slide number for the header. */
+    slideNumber: number;
+}
+/**
+ * Build a notes-page PDF byte stream from pre-converted slide JPEG data and the
+ * matching per-slide notes metadata.
+ *
+ * @param images - JPEG image data, one entry per slide (index-aligned to `meta`).
+ * @param meta   - Notes + slide-number for each slide (index-aligned to `images`).
+ * @returns The assembled PDF as a single `Uint8Array`.
+ */
+export declare function buildNotesPdfBytes(images: PdfImageData[], meta: NotesPageMeta[]): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=pdf-notes-builder.d.ts.map

package/dist/pptx/export/pdf-notes-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-notes-builder.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/pdf-notes-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAgBH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD,0EAA0E;AAC1E,MAAM,WAAW,aAAa;IAC7B,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;CACpB;AAWD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,YAAY,EAAE,EACtB,IAAI,EAAE,aAAa,EAAE,GACnB,UAAU,CAAC,WAAW,CAAC,CAoMzB"}

package/dist/pptx/export/pdf-notes-layout.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Pure notes-page PDF layout calculation, text wrapping, and content-stream
+ * helpers  -  shared by every binding's PDF export path.
+ *
+ * These functions have no DOM dependency: they compute page geometry (in PDF
+ * points), wrap plain-text speaker notes, and emit PDF content-stream fragments.
+ * The binding owns canvas→JPEG conversion and the final `Blob`/object-URL.
+ */
+/** US Letter portrait width in PDF points (8.5 x 72). */
+export declare const NOTES_PAGE_W = 612;
+/** US Letter portrait height in PDF points (11 x 72). */
+export declare const NOTES_PAGE_H = 792;
+/** Page margin in points. */
+export declare const NOTES_MARGIN = 36;
+/** Fraction of the usable height allocated to the slide image area. */
+export declare const NOTES_SLIDE_FRACTION: number;
+/** Gap between slide image area and notes text in points. */
+export declare const NOTES_GAP = 18;
+/** Font size for notes text in points. */
+export declare const NOTES_FONT_SIZE = 11;
+/** Line height multiplier for notes text. */
+export declare const NOTES_LINE_HEIGHT = 1.4;
+/** Border width around the slide image in points. */
+export declare const NOTES_BORDER_WIDTH = 0.5;
+/** Font size for the continuation page header in points. */
+export declare const NOTES_CONTINUATION_HEADER_SIZE = 9;
+/** Pre-converted image data for PDF embedding. */
+export interface PdfImageData {
+    /** Raw JPEG bytes. */
+    bytes: Uint8Array;
+    /** Image pixel width. */
+    w: number;
+    /** Image pixel height. */
+    h: number;
+}
+/** Computed geometry for a single notes page (all values in PDF points). */
+export interface NotesPdfPageLayout {
+    /** Available content width (page minus margins). */
+    contentWidth: number;
+    /** Available content height (page minus margins). */
+    contentHeight: number;
+    /** Height allocated to the slide image area. */
+    slideAreaHeight: number;
+    /** Height allocated to the notes text area. */
+    notesAreaHeight: number;
+    /** Rendered slide image width (aspect-ratio preserved). */
+    imageWidth: number;
+    /** Rendered slide image height (aspect-ratio preserved). */
+    imageHeight: number;
+    /** X position of the slide image (centered). */
+    imageX: number;
+    /** Y position of the slide image (PDF coords, origin at bottom-left). */
+    imageY: number;
+    /** Y position where notes text starts (PDF coords, origin at bottom-left). */
+    notesTextY: number;
+    /** Maximum number of notes text lines that fit. */
+    maxNotesLines: number;
+}
+/**
+ * Calculate the layout geometry for a single notes page.
+ *
+ * @param slideWidth Pixel width of the captured slide canvas.
+ * @param slideHeight Pixel height of the captured slide canvas.
+ */
+export declare function calculateNotesPageLayout(slideWidth: number, slideHeight: number): NotesPdfPageLayout;
+/**
+ * Wrap a text string into lines that fit within a given width at a given font
+ * size, using approximate Helvetica character widths (acceptable for plain
+ * speaker notes). Blank authored paragraphs keep their vertical gap so the
+ * printed notes match how the author spaced them.
+ */
+export declare function wrapNotesText(text: string, maxWidth: number, fontSize: number): string[];
+/**
+ * Calculate the maximum number of notes text lines that fit on a continuation
+ * page (text-only, no slide image).
+ */
+export declare function calculateContinuationPageMaxLines(): number;
+/**
+ * Escape special PDF text characters in a string for use in Tj operators.
+ */
+export declare function escapePdfText(text: string): string;
+/**
+ * Build a content stream for notes text lines starting at the given Y position.
+ */
+export declare function buildNotesTextStream(lines: string[], startY: number): string;
+//# sourceMappingURL=pdf-notes-layout.d.ts.map

package/dist/pptx/export/pdf-notes-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-notes-layout.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/pdf-notes-layout.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAQH,yDAAyD;AACzD,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,yDAAyD;AACzD,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,6BAA6B;AAC7B,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,uEAAuE;AACvE,eAAO,MAAM,oBAAoB,QAAQ,CAAC;AAC1C,6DAA6D;AAC7D,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,0CAA0C;AAC1C,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,6CAA6C;AAC7C,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,qDAAqD;AACrD,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,4DAA4D;AAC5D,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,kDAAkD;AAClD,MAAM,WAAW,YAAY;IAC5B,sBAAsB;IACtB,KAAK,EAAE,UAAU,CAAC;IAClB,yBAAyB;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,0BAA0B;IAC1B,CAAC,EAAE,MAAM,CAAC;CACV;AAED,4EAA4E;AAC5E,MAAM,WAAW,kBAAkB;IAClC,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,aAAa,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,eAAe,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,eAAe,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC;CACtB;AAMD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACvC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACjB,kBAAkB,CAqCpB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAExF;AAED;;;GAGG;AACH,wBAAgB,iCAAiC,IAAI,MAAM,CAO1D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAmB5E"}

package/dist/pptx/export/pdf-page-size.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var chunk73IDQGYI_cjs = require('../chunk-73IDQGYI.cjs');
+
+
+
+Object.defineProperty(exports, "pdfOrientation", {
+  enumerable: true,
+  get: function () { return chunk73IDQGYI_cjs.pdfOrientation; }
+});
+Object.defineProperty(exports, "pdfPageSize", {
+  enumerable: true,
+  get: function () { return chunk73IDQGYI_cjs.pdfPageSize; }
+});
+Object.defineProperty(exports, "sanitizeFileName", {
+  enumerable: true,
+  get: function () { return chunk73IDQGYI_cjs.sanitizeFileName; }
+});
+Object.defineProperty(exports, "slideFileName", {
+  enumerable: true,
+  get: function () { return chunk73IDQGYI_cjs.slideFileName; }
+});

package/dist/pptx/export/pdf-page-size.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Pure PDF page-size / file-name helpers shared by every binding's image+PDF
+ * export. No DOM, no jsPDF, no html2canvas.
+ *
+ * All page-size values are in points (pt), the unit jsPDF uses natively
+ * (1 pt = 1/72 inch). The slide pixel dimensions passed in are treated as a
+ * logical size for aspect-ratio maths only; the resulting PDF pages are scaled
+ * to fit within standard A4.
+ */
+/**
+ * Determine jsPDF page orientation from the slide's pixel width and height.
+ * `w > h` is landscape; otherwise portrait.
+ */
+export declare function pdfOrientation(w: number, h: number): 'landscape' | 'portrait';
+/**
+ * Compute the jsPDF page dimensions (in pt) for the slide, preserving the slide
+ * aspect ratio within A4 bounds. The returned `{ width, height }` are the
+ * MediaBox dimensions to pass to `new jsPDF({ unit: 'pt', format: [w, h] })`.
+ *
+ * @param w - Slide canvas width in pixels.
+ * @param h - Slide canvas height in pixels.
+ */
+export declare function pdfPageSize(w: number, h: number): {
+    width: number;
+    height: number;
+    orientation: 'landscape' | 'portrait';
+};
+/**
+ * Sanitize a file-name by replacing characters that are unsafe on Windows,
+ * macOS, and Linux file systems with an underscore. Stripped characters:
+ * `\ / : * ? " < > |` and ASCII control codes (0-31).
+ */
+export declare function sanitizeFileName(name: string): string;
+/**
+ * Build a per-slide file name from a base name, 1-based slide index, and
+ * extension (without the leading dot).
+ */
+export declare function slideFileName(baseName: string, index: number, ext: string): string;
+//# sourceMappingURL=pdf-page-size.d.ts.map

package/dist/pptx/export/pdf-page-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-page-size.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/pdf-page-size.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,UAAU,CAE7E;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAC1B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACP;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,WAAW,GAAG,UAAU,CAAA;CAAE,CAM1E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAElF"}

package/dist/pptx/export/pdf-page-size.mjs

@@ -0,0 +1 @@
+export { pdfOrientation, pdfPageSize, sanitizeFileName, slideFileName } from '../chunk-A62C6PSL.mjs';

package/dist/pptx/export/pdf-slides.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Pure slides-only PDF byte assembly, shared by every binding's PDF export.
+ *
+ * Given pre-converted JPEG image data (one per slide), build a minimal valid
+ * PDF 1.4 byte stream with one slide image per landscape A4 page. No DOM
+ * dependency: the binding owns canvas->JPEG conversion and the final
+ * `Blob`/object-URL.
+ */
+import type { PdfImageData } from './pdf-notes-layout.js';
+/**
+ * Landscape A4 page size, in points, that every page `buildSlidesPdfBytes`/
+ * `buildTiledSlidesPdfBytes` writes uses. Exported so a caller computing tile
+ * placements (`placeTileOnPage` in `pdf-tile-placement.ts`) passes the exact
+ * same page size the PDF bytes are actually built with, rather than
+ * re-deriving a slightly different rounding (`pdf-page-size.ts`'s
+ * `A4_PT_W`/`A4_PT_H` are unrelated: that module sizes a *fitted, orientation-
+ * aware* page for the vue/svelte/vanilla/angular jsPDF path, which this
+ * fixed-landscape hand-rolled encoder does not use).
+ */
+export declare const PDF_SLIDES_PAGE_WIDTH_PT = 842;
+export declare const PDF_SLIDES_PAGE_HEIGHT_PT = 595;
+/**
+ * Build a PDF byte stream from pre-converted JPEG image data.
+ *
+ * Each image becomes a full page in landscape A4 (842 x 595 pt).
+ *
+ * @param images - Array of pre-converted JPEG image data.
+ * @returns The assembled PDF as a single `Uint8Array`.
+ */
+export declare function buildSlidesPdfBytes(images: PdfImageData[]): Uint8Array<ArrayBuffer>;
+/** One tile image and where it lands on its PDF page (see `pdf-tile-placement.ts`). */
+export interface PdfTiledPageImage {
+    image: PdfImageData;
+    /** Top-down PDF-page-point placement (y grows downward from the page's top edge). */
+    placement: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Build a PDF byte stream where each page may be composed of several tile
+ * images (`placeTileOnPage` in `pdf-tile-placement.ts` computes each tile's
+ * placement) instead of exactly one full-page image. This is what lets a PDF
+ * export escape the browser canvas cap: every tile is individually small
+ * (each came from a capped-size canvas), but a PDF page has no canvas-size
+ * limit of its own to bump into.
+ *
+ * A single-tile page (the overwhelming majority - most exports never need
+ * tiling) degrades to exactly the same page {@link buildSlidesPdfBytes}
+ * would produce.
+ *
+ * @param pages - One entry per page; each entry is that page's tile images
+ *   and their placements, in any order (the content stream draws them in
+ *   list order, which does not matter since tiles never overlap).
+ */
+export declare function buildTiledSlidesPdfBytes(pages: PdfTiledPageImage[][]): Uint8Array<ArrayBuffer>;
+/** Merge a list of string/binary segments into a single `Uint8Array`. */
+export declare function mergeSegments(segments: (string | Uint8Array)[]): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=pdf-slides.d.ts.map

package/dist/pptx/export/pdf-slides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-slides.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/pdf-slides.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,UAAU,CAAC,WAAW,CAAC,CAuFnF;AAED,uFAAuF;AACvF,MAAM,WAAW,iBAAiB;IACjC,KAAK,EAAE,YAAY,CAAC;IACpB,qFAAqF;IACrF,SAAS,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACnE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,iBAAiB,EAAE,EAAE,GAAG,UAAU,CAAC,WAAW,CAAC,CA+F9F;AAED,yEAAyE;AACzE,wBAAgB,aAAa,CAAC,QAAQ,EAAE,CAAC,MAAM,GAAG,UAAU,CAAC,EAAE,GAAG,UAAU,CAAC,WAAW,CAAC,CAmBxF"}

package/dist/pptx/export/pdf-tile-placement.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pure geometry for placing one export tile (from `rasterize-element-tiles.ts`)
+ * onto a PDF page, so PDF/notes-PDF export can embed several small,
+ * cap-respecting tile images per page instead of one full-page image -
+ * escaping the browser canvas cap for PDF the same way PNG export does,
+ * without ever needing to stitch a PNG at all (a PDF page has no canvas-size
+ * limit of its own).
+ *
+ * Every tile is placed exactly where a single full-page image would have
+ * been fitted (preserving aspect ratio, centered within the page): this one
+ * function covers both a native-size page (`pageWidth`/`pageHeight` equal to
+ * the element's natural size, the vue/svelte/vanilla/angular jsPDF
+ * convention, where the fit is exact and `offsetX`/`offsetY` are always 0)
+ * and a fixed page size the image is letterboxed into (the react hand-rolled
+ * PDF encoder's fixed-A4 convention).
+ *
+ * Coordinates returned are **top-down** (y grows downward from the page's
+ * top edge), matching both the DOM/tile convention this module reads from
+ * and jsPDF's own `addImage(data, format, x, y, w, h)` contract. A caller
+ * writing raw PDF content-stream bytes (whose native coordinate space is
+ * bottom-up) must flip: `rawY = pageHeight - placement.y - placement.height`.
+ */
+/** A tile's full-raster rectangle, in device pixels (see `RasterizedTile`). */
+export interface TileDeviceRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Where a tile lands on the page, in the page's own units (pt or px). Top-down. */
+export interface TilePagePlacement {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Compute `tile`'s placement on a `pageWidth` x `pageHeight` page, given the
+ * full (un-tiled) raster's device-pixel size. The full raster is fitted into
+ * the page preserving aspect ratio and centered, exactly like a single
+ * full-page image would be; `tile` occupies the proportional sub-rectangle
+ * of that fitted placement.
+ */
+export declare function placeTileOnPage(tile: TileDeviceRect, fullWidth: number, fullHeight: number, pageWidth: number, pageHeight: number): TilePagePlacement;
+//# sourceMappingURL=pdf-tile-placement.d.ts.map

package/dist/pptx/export/pdf-tile-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-tile-placement.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/pdf-tile-placement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,oFAAoF;AACpF,MAAM,WAAW,iBAAiB;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,cAAc,EACpB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAChB,iBAAiB,CAcnB"}

package/dist/pptx/export/png-chunk-builder.d.ts

@@ -0,0 +1,22 @@
+/** The 8-byte PNG file signature, always first. */
+export declare const PNG_SIGNATURE: Uint8Array<ArrayBuffer>;
+/**
+ * Frame one PNG chunk: 4-byte big-endian length, 4-byte ASCII type, the raw
+ * data, then a CRC-32 over (type + data).
+ */
+export declare function buildPngChunk(type: string, data: Uint8Array): Uint8Array;
+/** PNG colour type for 8-bit-per-channel RGBA (what `getImageData` produces). */
+export declare const PNG_COLOR_TYPE_RGBA = 6;
+/** Build the `IHDR` chunk for an 8-bit RGBA, non-interlaced image. */
+export declare function buildIhdrChunk(width: number, height: number): Uint8Array;
+/** Build the empty `IEND` chunk that terminates every PNG file. */
+export declare function buildIendChunk(): Uint8Array;
+/**
+ * Assemble a complete PNG file from its pieces: signature, IHDR, one or more
+ * already-framed IDAT chunks (a zlib stream may be split across several
+ * IDATs; PNG readers concatenate their data before inflating), and IEND.
+ */
+export declare function assemblePng(width: number, height: number, idatChunks: readonly Uint8Array[]): Uint8Array;
+/** Wrap a raw zlib-compressed byte buffer in one `IDAT` chunk. */
+export declare function buildIdatChunk(zlibBytes: Uint8Array): Uint8Array;
+//# sourceMappingURL=png-chunk-builder.d.ts.map

package/dist/pptx/export/png-chunk-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png-chunk-builder.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/png-chunk-builder.ts"],"names":[],"mappings":"AAWA,mDAAmD;AACnD,eAAO,MAAM,aAAa,yBAAmE,CAAC;AA8B9F;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAIxE;AAED,iFAAiF;AACjF,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAUxE;AAED,mEAAmE;AACnE,wBAAgB,cAAc,IAAI,UAAU,CAE3C;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,SAAS,UAAU,EAAE,GAC/B,UAAU,CAOZ;AAED,kEAAkE;AAClE,wBAAgB,cAAc,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU,CAEhE"}

package/dist/pptx/export/png-crc32.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CRC-32 (PNG's checksum, ISO 3309 / ITU-T V.42 polynomial 0xEDB88320) pure
+ * byte-level implementation. Used to checksum every PNG chunk in
+ * `png-chunk-builder`. No external dependency, mirroring the house style of
+ * `gif-encoder.ts` (self-contained byte encoders with no npm image library).
+ */
+/** CRC-32 checksum of `bytes`, as required by every PNG chunk trailer. */
+export declare function crc32(bytes: Uint8Array): number;
+//# sourceMappingURL=png-crc32.d.ts.map