ooxml-ui 0.30.0 → 0.31.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"png-crc32.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/png-crc32.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoBH,0EAA0E;AAC1E,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAO/C"}

package/dist/pptx/export/png-row-filter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PNG scanline filtering (pure byte math, no compression). Every PNG
+ * scanline is prefixed with a one-byte filter-type tag; filter type 0
+ * ("None") is used here, the simplest legal choice. It does not shrink the
+ * pre-compression size the way Sub/Up/Paeth would, but `streaming-png-encoder`
+ * still deflates the result through the browser's native `CompressionStream`,
+ * so output stays reasonably small while this module stays trivially correct
+ * and independent of pixel content (important for the row-band streaming
+ * path, which never has adjacent rows from other tiles in memory to filter
+ * against).
+ */
+/** Bytes per pixel for 8-bit RGBA, PNG's `getImageData`-native format. */
+export declare const RGBA_BYTES_PER_PIXEL = 4;
+/**
+ * Prefix one scanline of RGBA pixel bytes with the filter-type-0 tag.
+ *
+ * @param rowRgba - Exactly `width * 4` bytes for one image row.
+ */
+export declare function filterRowNone(rowRgba: Uint8Array): Uint8Array;
+/**
+ * Filter every row of a full RGBA pixel block (`height` rows of `width * 4`
+ * bytes each) and concatenate the results, producing the exact byte layout
+ * PNG's IDAT stream expects before deflate compression.
+ */
+export declare function filterPixelBlock(pixels: Uint8Array, width: number, height: number): Uint8Array;
+//# sourceMappingURL=png-row-filter.d.ts.map

package/dist/pptx/export/png-row-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png-row-filter.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/png-row-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAK7D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAc9F"}

package/dist/pptx/export/print-document.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var chunkX4FNVH7J_cjs = require('../chunk-X4FNVH7J.cjs');
+require('../chunk-FGKPZFLL.cjs');
+require('../chunk-UPN5FFKP.cjs');
+require('../chunk-EW5DW5KR.cjs');
+
+
+
+Object.defineProperty(exports, "DEFAULT_PRINT_SETTINGS", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.DEFAULT_PRINT_SETTINGS; }
+});
+Object.defineProperty(exports, "buildHandoutsHtml", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.buildHandoutsHtml; }
+});
+Object.defineProperty(exports, "buildNotesHtml", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.buildNotesHtml; }
+});
+Object.defineProperty(exports, "buildOutlineHtml", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.buildOutlineHtml; }
+});
+Object.defineProperty(exports, "buildPrintHtmlDocument", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.buildPrintHtmlDocument; }
+});
+Object.defineProperty(exports, "buildSlidesHtml", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.buildSlidesHtml; }
+});
+Object.defineProperty(exports, "computeColorFilter", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.computeColorFilter; }
+});
+Object.defineProperty(exports, "computePrintPageCount", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.computePrintPageCount; }
+});
+Object.defineProperty(exports, "computeSlideCount", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.computeSlideCount; }
+});
+Object.defineProperty(exports, "computeSlideIndices", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.computeSlideIndices; }
+});
+Object.defineProperty(exports, "effectiveOrientation", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.effectiveOrientation; }
+});
+Object.defineProperty(exports, "estimatePageCount", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.estimatePageCount; }
+});
+Object.defineProperty(exports, "filterHiddenSlideIndices", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.filterHiddenSlideIndices; }
+});
+Object.defineProperty(exports, "normalizeSlidesPerPage", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.normalizeSlidesPerPage; }
+});
+Object.defineProperty(exports, "slideTitle", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.slideTitle; }
+});
+Object.defineProperty(exports, "validatePrintSettings", {
+  enumerable: true,
+  get: function () { return chunkX4FNVH7J_cjs.validatePrintSettings; }
+});

package/dist/pptx/export/print-document.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Pure print helpers shared by every binding's print path: settings validation,
+ * slide-range / colour-filter resolution, page-count estimation, HTML markup
+ * builders, escaping, and the full print-document assembler.
+ *
+ * No DOM side effects and no `window.print()`: everything is deterministic and
+ * the binding writes the returned HTML string into a print window. The handout
+ * grid geometry lives in `handout-layout`; this module reuses it. Handout
+ * master "chrome" (background/header/footer/date/page-number/positioned slide
+ * rects) is resolved by `handout-master-chrome.ts` and painted by
+ * `handout-chrome-html.ts`; escaping helpers live in `html-escape.ts` (both
+ * split out to keep this file under this repo's per-file LOC guideline and to
+ * avoid a circular import between the two).
+ */
+import type { PptxHandoutMaster, PptxSlide } from 'ooxml-core/pptx';
+import type { HandoutSlidesPerPage } from './handout-layout.js';
+/** What to print. */
+export type PrintWhat = 'slides' | 'handouts' | 'notes' | 'outline';
+/** Page orientation for the printed output. */
+export type PrintOrientation = 'portrait' | 'landscape';
+/** Colour mode for the printed output. */
+export type PrintColorMode = 'color' | 'grayscale' | 'blackAndWhite';
+/** Slide range mode. */
+export type PrintSlideRange = 'all' | 'current' | 'custom';
+/** Resolved print settings emitted on confirm. */
+export interface PrintSettings {
+    printWhat: PrintWhat;
+    orientation: PrintOrientation;
+    colorMode: PrintColorMode;
+    frameSlides: boolean;
+    slidesPerPage: HandoutSlidesPerPage;
+    slideRange: PrintSlideRange;
+    customRangeFrom: number;
+    customRangeTo: number;
+    /**
+     * PowerPoint's Print > "Scale to Fit Paper". `true` (the default, and the
+     * only behavior this printed output ever had before this field existed)
+     * shrinks/grows each slide image to fill its page/cell while preserving
+     * aspect ratio. `false` prints at the slide's native pixel size instead,
+     * which may overflow or under-fill the page, exactly like PowerPoint with
+     * the option off. Optional so existing `Partial<PrintSettings>` literals
+     * across every binding keep compiling; `validatePrintSettings` defaults it
+     * to `true`.
+     */
+    scaleToFit?: boolean;
+}
+/** Default print settings used when the dialog opens. */
+export declare const DEFAULT_PRINT_SETTINGS: PrintSettings;
+/**
+ * Coerce an arbitrary number to a supported {@link HandoutSlidesPerPage}.
+ * Falls back to 6 (the PowerPoint default) when the value is unsupported.
+ */
+export declare function normalizeSlidesPerPage(value: number | undefined): HandoutSlidesPerPage;
+/**
+ * Validate and clamp partial print settings into a fully-resolved
+ * {@link PrintSettings}. Custom-range bounds are clamped to `[1, slideCount]`
+ * (with `from <= to`), and `notes`/`outline`/`handouts` force portrait
+ * orientation.
+ *
+ * @param partial    - Caller-provided settings (any subset).
+ * @param slideCount - Total number of slides in the presentation.
+ */
+export declare function validatePrintSettings(partial: Partial<PrintSettings>, slideCount: number): PrintSettings;
+/**
+ * The orientation actually used for a given print mode. Only full-page
+ * `slides` honour the user-chosen orientation; everything else is portrait.
+ */
+export declare function effectiveOrientation(printWhat: PrintWhat, orientation: PrintOrientation): PrintOrientation;
+/**
+ * Compute the zero-based slide indices to print from a slide-range setting.
+ * Custom ranges use 1-based, inclusive `from`/`to` and are clamped to bounds.
+ */
+export declare function computeSlideIndices(slideRange: PrintSlideRange, activeSlideIndex: number, slideCount: number, customRangeFrom: number, customRangeTo: number): number[];
+/**
+ * Filter hidden slides out of a resolved index list, unless `includeHidden` is
+ * set. Mirrors PowerPoint: slides marked "hidden" (skipped during normal
+ * presentation) are excluded from print output by default too (Options >
+ * Advanced > "Print hidden slides" turns that off).
+ *
+ * A post-filter over {@link computeSlideIndices}'s output rather than a new
+ * parameter on that function: `computeSlideIndices` is called from every
+ * binding's print path already and only ever received a `slideCount`, so
+ * threading the slides array (or a hidden-flags array) through its signature
+ * would be a breaking change to a widely-called function for one option.
+ */
+export declare function filterHiddenSlideIndices(indices: number[], slides: PptxSlide[], includeHidden: boolean): number[];
+/**
+ * Number of slides selected by the given range. Custom ranges use 1-based,
+ * inclusive `from`/`to` clamped to `[1, slideCount]`; an inverted range
+ * collapses to a single slide.
+ */
+export declare function computeSlideCount(slideRange: PrintSlideRange, slideCount: number, customRangeFrom: number, customRangeTo: number): number;
+/** CSS `filter:` declaration for the chosen colour mode (empty for full colour). */
+export declare function computeColorFilter(colorMode: PrintColorMode): string;
+/** Number of pages needed for `slideCount` slides at `slidesPerPage`. */
+export declare function computePrintPageCount(slideCount: number, slidesPerPage: HandoutSlidesPerPage): number;
+/**
+ * Estimate the printed page count for the full settings object: slides and
+ * notes are one page each; outline is a single page; handouts paginate.
+ */
+export declare function estimatePageCount(printWhat: PrintWhat, slideCount: number, slidesPerPage: HandoutSlidesPerPage): number;
+/**
+ * Best-effort slide title: the first element carrying non-empty `text`,
+ * falling back to `Slide N` (1-based).
+ */
+export declare function slideTitle(slide: PptxSlide | undefined, index: number): string;
+/** Build the outline body markup (`<h2>` title + optional `<p>` notes per slide). */
+export declare function buildOutlineHtml(slideIndices: number[], slides: PptxSlide[]): string;
+/** Build the body markup for full-page slide printing (one `<section>` each). */
+export declare function buildSlidesHtml(slideImages: string[], slideIndices: number[]): string;
+/** Build the body markup for notes-page printing (slide thumbnail + notes). */
+export declare function buildNotesHtml(slideImages: string[], slideIndices: number[], slides: PptxSlide[]): string;
+/**
+ * Build the body markup for handout printing. The grid is derived from
+ * `slidesPerPage`; the 3-per-page layout adds ruled note lines on the right.
+ *
+ * `handoutMaster`, when supplied, paints its background, header/footer/date/
+ * page-number placeholders (per `handoutMasterChrome`), and, when it defines
+ * positioned slide-image placeholders, sizes the slide cells from them
+ * instead of the app-computed grid (skipped for the 3-per-page layout, whose
+ * note-line column has no equivalent in placeholder geometry). Omitting it
+ * (existing callers) renders byte-identical output to before this parameter
+ * existed.
+ */
+export declare function buildHandoutsHtml(slideImages: string[], slideIndices: number[], slidesPerPage: HandoutSlidesPerPage, handoutMaster?: PptxHandoutMaster): string;
+/** Options for {@link buildPrintHtmlDocument}. */
+export interface PrintHtmlDocumentOptions {
+    title: string;
+    bodyHtml: string;
+    orientation: PrintOrientation;
+    colorFilter: string;
+    frameSlides: boolean;
+    /**
+     * PowerPoint's Print > "Scale to Fit Paper". Defaults to `true` (shrink/grow
+     * each slide image to fill its page/cell, the only behavior this printed
+     * output ever had before this option existed). `false` prints images at
+     * their native size instead, which may overflow (clipped by the cell's
+     * `overflow: hidden`) or under-fill the page/cell.
+     */
+    scaleToFit?: boolean;
+}
+/**
+ * Assemble the complete printable HTML document string (doctype + head with
+ * print CSS + body). Pure: the caller writes it into a print window.
+ */
+export declare function buildPrintHtmlDocument(options: PrintHtmlDocumentOptions): string;
+//# sourceMappingURL=print-document.d.ts.map

package/dist/pptx/export/print-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-document.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/print-document.ts"],"names":[],"mappings":"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"}

package/dist/pptx/export/print-document.mjs

@@ -0,0 +1,4 @@
+export { DEFAULT_PRINT_SETTINGS, buildHandoutsHtml, buildNotesHtml, buildOutlineHtml, buildPrintHtmlDocument, buildSlidesHtml, computeColorFilter, computePrintPageCount, computeSlideCount, computeSlideIndices, effectiveOrientation, estimatePageCount, filterHiddenSlideIndices, normalizeSlidesPerPage, slideTitle, validatePrintSettings } from '../chunk-3ZI57W7O.mjs';
+import '../chunk-IXFG46KB.mjs';
+import '../chunk-IEAO7N4E.mjs';
+import '../chunk-WHUMPYEM.mjs';

package/dist/pptx/export/print-window.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Open a blank print window right now, synchronously, still inside the
+ * click's call stack, with a placeholder page. Returns `null` if the popup
+ * was blocked (fully disabled popups, say) -- callers should surface that to
+ * the user (e.g. "allow popups for this site to print") rather than silently
+ * doing nothing.
+ *
+ * @param preparingLabel - Host-translated "Preparing to print…" text shown
+ *   in the placeholder while the real document is assembled.
+ */
+export declare function openPendingPrintWindow(preparingLabel: string): Window | null;
+/**
+ * Write the final print document into an already-open print window (from
+ * {@link openPendingPrintWindow}, or opened directly for a path that never
+ * awaits anything first), focus it, and trigger the print dialog.
+ */
+export declare function finishPrintWindow(printWindow: Window, htmlDocument: string): void;
+/**
+ * Open a print window and write a complete document into it in one
+ * synchronous call. Only safe for a path that never `await`s before this
+ * point (outline; direct SVG slides) -- one that does needs the
+ * `openPendingPrintWindow`/`finishPrintWindow` split instead, called before
+ * and after its `await`s respectively.
+ */
+export declare function openPrintWindow(htmlDocument: string): boolean;
+//# sourceMappingURL=print-window.d.ts.map

package/dist/pptx/export/print-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-window.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/print-window.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAY5E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAQjF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAO7D"}

package/dist/pptx/export/raster-result-to-blob.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Convert a {@link RasterizeElementResult} (from `rasterize-element.ts`) into
+ * a PNG `Blob`, handling both branches identically for every binding:
+ * - `kind: 'canvas'` (the overwhelming majority of exports): wraps the
+ *   canvas via `toBlob`.
+ * - `kind: 'png-bytes'` (a tiled export whose full resolution exceeded the
+ *   browser's canvas cap): wraps the already-encoded PNG bytes directly, no
+ *   canvas involved at all, which is exactly what makes an export beyond the
+ *   cap possible in the first place.
+ *
+ * Every binding's PNG-export / "copy slide as image" handler needs this
+ * exact same branch, so it lives once here instead of being hand-copied five
+ * times (the extraction trigger CLAUDE.md calls out: "I am making the same
+ * edit in N bindings").
+ */
+import type { RasterizeElementResult } from './rasterize-element.js';
+/** Convert a {@link RasterizeElementResult} to a PNG `Blob`. */
+export declare function rasterResultToPngBlob(result: RasterizeElementResult): Promise<Blob>;
+/** Convert a {@link RasterizeElementResult} to a PNG `data:` URL (for callers that need a string, not a `Blob`). */
+export declare function rasterResultToPngDataUrl(result: RasterizeElementResult): Promise<string>;
+//# sourceMappingURL=raster-result-to-blob.d.ts.map

package/dist/pptx/export/raster-result-to-blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raster-result-to-blob.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/raster-result-to-blob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAElE,gEAAgE;AAChE,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAazF;AAED,oHAAoH;AACpH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,CAW9F"}

package/dist/pptx/export/rasterize-element-clamped.d.ts

@@ -0,0 +1,15 @@
+import type { RasterizeElementCanvasResult, RasterizeElementOptions } from './rasterize-element.js';
+/** Same result as the common (non-tiled) `rasterizeElement()` case, plus whether the scale had to be reduced. */
+export interface RasterizeElementClampedResult extends RasterizeElementCanvasResult {
+    /** `true` when `options.scale` was reduced to fit the canvas cap. */
+    clamped: boolean;
+    /** The scale actually used (equals `options.scale` unless `clamped`). */
+    effectiveScale: number;
+}
+/**
+ * Rasterise `element`, reducing `options.scale` (preserving aspect ratio) so
+ * the full raster never exceeds the browser's canvas-dimension cap, and
+ * therefore never tiles.
+ */
+export declare function rasterizeElementClampedToCanvas(element: HTMLElement, naturalWidth: number, naturalHeight: number, doc: Document, options: RasterizeElementOptions): Promise<RasterizeElementClampedResult>;
+//# sourceMappingURL=rasterize-element-clamped.d.ts.map

package/dist/pptx/export/rasterize-element-clamped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterize-element-clamped.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/rasterize-element-clamped.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,4BAA4B,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAGjG,iHAAiH;AACjH,MAAM,WAAW,6BAA8B,SAAQ,4BAA4B;IAClF,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,cAAc,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAsB,+BAA+B,CACpD,OAAO,EAAE,WAAW,EACpB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,QAAQ,EACb,OAAO,EAAE,uBAAuB,GAC9B,OAAO,CAAC,6BAA6B,CAAC,CAyBxC"}

package/dist/pptx/export/rasterize-element-strategy.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Strategy selection for rasterising one export window (the whole slide for
+ * a non-tiled export, or one tile's rectangle for a tiled export). Tries, in
+ * order: the SVG `foreignObject` path (preserves `backdrop-filter`, custom
+ * properties, 3D transforms because the browser's own engine paints it),
+ * then the existing vector-SVG export pipeline rasterised the same way
+ * (covers the case a resource could not be embedded as `data:`, so
+ * `foreignObject` would taint the canvas), then `html2canvas-pro` as the
+ * documented last resort. Every binding's `renderToCanvas` wrapper calls
+ * this once per window; only the `html2canvasFallback` driver (the
+ * `html2canvas-pro` import itself) stays per-binding.
+ */
+import type { ForeignObjectSvgBody } from '../render/foreign-object-svg-document.js';
+/** Which path actually produced the tile, for telemetry/tests. */
+export type RasterStrategy = 'foreignObject' | 'vectorSvg' | 'html2canvas';
+/** A window into the element's natural (unscaled) coordinate space. */
+export interface RasterSourceRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** The device-pixel size to rasterise `RasterSourceRect` at. */
+export interface RasterOutputSize {
+    width: number;
+    height: number;
+}
+/** Escape-hatch + fallback wiring, shared by every window/tile of one export. */
+export interface RasterStrategyOptions {
+    /**
+     * `'html2canvas'` skips straight to the documented legacy fallback (for
+     * callers/tests that need html2canvas-pro's exact historical output).
+     * Default `'auto'` tries `foreignObject` first.
+     */
+    mode?: 'auto' | 'html2canvas';
+    /**
+     * Re-windows the existing vector-SVG export pipeline's output
+     * (`ooxml-core/pptx`'s `SvgExporter`, already produced by the caller at
+     * the element's natural size) to `sourceRect`/`outputSize`. Omit to skip
+     * straight to `html2canvasFallback` when `foreignObject` fails.
+     */
+    vectorSvgFallback?: (sourceRect: RasterSourceRect, outputSize: RasterOutputSize) => Promise<HTMLCanvasElement>;
+    /** The per-binding `html2canvas-pro` driver, last resort. */
+    html2canvasFallback: (sourceRect: RasterSourceRect, outputSize: RasterOutputSize) => Promise<HTMLCanvasElement>;
+    /** Called whenever a strategy is attempted and fails, for diagnostics/telemetry. */
+    onStrategyFailed?: (strategy: RasterStrategy, error: unknown) => void;
+}
+/** One rasterised window plus which strategy produced it. */
+export interface RasterStrategyResult {
+    canvas: HTMLCanvasElement;
+    strategy: RasterStrategy;
+}
+/**
+ * Rasterise one window using `body` (already built once per element by the
+ * caller; see `rasterize-element.ts`) windowed to `sourceRect`, falling back
+ * through vector-SVG and html2canvas in order.
+ */
+export declare function rasterizeWindow(body: ForeignObjectSvgBody | undefined, sourceRect: RasterSourceRect, outputSize: RasterOutputSize, backgroundColor: string | undefined, options: RasterStrategyOptions): Promise<RasterStrategyResult>;
+//# sourceMappingURL=rasterize-element-strategy.d.ts.map

package/dist/pptx/export/rasterize-element-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterize-element-strategy.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/rasterize-element-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAIlF,kEAAkE;AAClE,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,WAAW,GAAG,aAAa,CAAC;AAE3E,uEAAuE;AACvE,MAAM,WAAW,gBAAgB;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,gEAAgE;AAChE,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,iFAAiF;AACjF,MAAM,WAAW,qBAAqB;IACrC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC;IAC9B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,CACnB,UAAU,EAAE,gBAAgB,EAC5B,UAAU,EAAE,gBAAgB,KACxB,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAChC,6DAA6D;IAC7D,mBAAmB,EAAE,CACpB,UAAU,EAAE,gBAAgB,EAC5B,UAAU,EAAE,gBAAgB,KACxB,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAChC,oFAAoF;IACpF,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACtE;AAED,6DAA6D;AAC7D,MAAM,WAAW,oBAAoB;IACpC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,cAAc,CAAC;CACzB;AAgDD;;;;GAIG;AACH,wBAAsB,eAAe,CACpC,IAAI,EAAE,oBAAoB,GAAG,SAAS,EACtC,UAAU,EAAE,gBAAgB,EAC5B,UAAU,EAAE,gBAAgB,EAC5B,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,OAAO,EAAE,qBAAqB,GAC5B,OAAO,CAAC,oBAAoB,CAAC,CAuC/B"}

package/dist/pptx/export/rasterize-element-tiled-canvas.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `rasterizeElement()`'s tiled case, stitched into a single full-resolution
+ * `<canvas>` via pure pixel-buffer math (`combineTileRowPixels` +
+ * `putImageData`) instead of pre-encoded PNG bytes - for a caller that needs
+ * an actual `<canvas>` to hand to a non-PNG consumer: an animated-GIF frame
+ * (`ctx.getImageData()`), or a `captureStream()`-backed recording canvas
+ * (`ctx.drawImage()`) for video export.
+ *
+ * Unlike `rasterizeElementClampedToCanvas`, the requested scale/resolution is
+ * never reduced: a full raster beyond the browser's canvas cap is rendered as
+ * several within-cap tiles (`rasterizeElementTiles()`) and stitched onto one
+ * full-size canvas the same way PNG/PDF export escape the cap, so GIF and
+ * video exports reach the same resolution PNG and PDF export do instead of
+ * silently downscaling. The non-tiled case (the overwhelming majority of
+ * exports) returns the single tile's own canvas unchanged, with no stitching
+ * cost at all.
+ */
+import type { RasterizeElementCanvasResult, RasterizeElementOptions } from './rasterize-element.js';
+/** Same shape as the common (non-tiled) `rasterizeElement()` case, plus whether stitching was needed. */
+export interface RasterizeElementTiledCanvasResult extends RasterizeElementCanvasResult {
+    /** `true` when the full raster needed more than one tile (stitched via `putImageData`, not a resolution cut). */
+    tiled: boolean;
+}
+/**
+ * Rasterise `element` (an attached, `naturalWidth` x `naturalHeight` CSS-pixel
+ * stage) at `options.scale` into a single full-resolution canvas, tiling and
+ * stitching transparently when the requested resolution exceeds the
+ * browser's canvas cap - never reducing the scale the way
+ * `rasterizeElementClampedToCanvas` does.
+ */
+export declare function rasterizeElementTiledToCanvas(element: HTMLElement, naturalWidth: number, naturalHeight: number, doc: Document, options: RasterizeElementOptions): Promise<RasterizeElementTiledCanvasResult>;
+//# sourceMappingURL=rasterize-element-tiled-canvas.d.ts.map

package/dist/pptx/export/rasterize-element-tiled-canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterize-element-tiled-canvas.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/rasterize-element-tiled-canvas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,4BAA4B,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAKjG,yGAAyG;AACzG,MAAM,WAAW,iCAAkC,SAAQ,4BAA4B;IACtF,iHAAiH;IACjH,KAAK,EAAE,OAAO,CAAC;CACf;AA+CD;;;;;;GAMG;AACH,wBAAsB,6BAA6B,CAClD,OAAO,EAAE,WAAW,EACpB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,QAAQ,EACb,OAAO,EAAE,uBAAuB,GAC9B,OAAO,CAAC,iCAAiC,CAAC,CAiC5C"}

package/dist/pptx/export/rasterize-element-tiles.d.ts

@@ -0,0 +1,46 @@
+import type { RasterizeElementOptions } from './rasterize-element.js';
+import type { RasterStrategy } from './rasterize-element-strategy.js';
+/** One rasterised tile: its full-raster position/size plus the canvas and strategy that produced it. */
+export interface RasterizedTile {
+    /** 0-based column index (tiles in the same row share increasing `col`). */
+    col: number;
+    /** 0-based row index. */
+    row: number;
+    /** Left edge, in full-raster device pixels. */
+    x: number;
+    /** Top edge, in full-raster device pixels. */
+    y: number;
+    width: number;
+    height: number;
+    canvas: HTMLCanvasElement;
+    strategy: RasterStrategy;
+}
+/** The full set of tiles covering one element's export, tiled or not. */
+export interface RasterizeElementTilesResult {
+    /** Full raster width in device pixels (sum of every column's width). */
+    fullWidth: number;
+    /** Full raster height in device pixels (sum of every row's height). */
+    fullHeight: number;
+    /** `false` when a single tile already covers the whole export. */
+    tiled: boolean;
+    /** Every tile, row-major order. Exactly one entry when `tiled` is `false`. */
+    tiles: RasterizedTile[];
+}
+/** Prefix of the console warning emitted when a raster strategy silently degrades. */
+export declare const RASTER_STRATEGY_FALLBACK_WARNING = "[pptx-viewer] raster export:";
+/**
+ * Rasterise `element` (an attached, `naturalWidth` x `naturalHeight` CSS-pixel
+ * stage) at `options.scale` into its raw per-tile canvases, tiling
+ * transparently whenever the requested resolution exceeds the browser's
+ * canvas cap. Builds the `foreignObject` SVG body once and reuses it for
+ * every tile (see `render/foreign-object-svg-document.ts`).
+ */
+export declare function rasterizeElementTiles(element: HTMLElement, naturalWidth: number, naturalHeight: number, doc: Document, options: RasterizeElementOptions): Promise<RasterizeElementTilesResult>;
+/**
+ * Group `tiles` (row-major, as returned by {@link rasterizeElementTiles}) into
+ * a 2D array indexed `[row][col]`. Shared by every caller that stitches tiles
+ * row-by-row (`rasterize-element.ts`'s PNG stitch, `rasterize-element-tiled-canvas.ts`'s
+ * canvas stitch) so the row/col grouping is written once.
+ */
+export declare function groupTilesByRow(tiles: readonly RasterizedTile[]): RasterizedTile[][];
+//# sourceMappingURL=rasterize-element-tiles.d.ts.map

package/dist/pptx/export/rasterize-element-tiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterize-element-tiles.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/rasterize-element-tiles.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAyB,MAAM,8BAA8B,CAAC;AAG1F,wGAAwG;AACxG,MAAM,WAAW,cAAc;IAC9B,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAC;IACZ,yBAAyB;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,+CAA+C;IAC/C,CAAC,EAAE,MAAM,CAAC;IACV,8CAA8C;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,cAAc,CAAC;CACzB;AAED,yEAAyE;AACzE,MAAM,WAAW,2BAA2B;IAC3C,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,KAAK,EAAE,OAAO,CAAC;IACf,8EAA8E;IAC9E,KAAK,EAAE,cAAc,EAAE,CAAC;CACxB;AAED,sFAAsF;AACtF,eAAO,MAAM,gCAAgC,iCAAiC,CAAC;AAgB/E;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAC1C,OAAO,EAAE,WAAW,EACpB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,QAAQ,EACb,OAAO,EAAE,uBAAuB,GAC9B,OAAO,CAAC,2BAA2B,CAAC,CAkDtC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,cAAc,EAAE,EAAE,CAcpF"}

package/dist/pptx/export/rasterize-element.d.ts

@@ -0,0 +1,45 @@
+import type { RasterStrategy, RasterStrategyOptions } from './rasterize-element-strategy.js';
+/** Options controlling one element's raster export. */
+export interface RasterizeElementOptions {
+    /** Export scale multiplier on top of the element's natural (1x) size. Default 1. */
+    scale?: number;
+    /** Solid background painted behind transparent content. */
+    backgroundColor?: string;
+    /** Override the probed canvas-dimension cap (mainly a test seam). */
+    maxCanvasDim?: number;
+    /** `'html2canvas'` skips straight to the documented legacy fallback. Default `'auto'`. */
+    mode?: RasterStrategyOptions['mode'];
+    /** Re-windows the existing vector-SVG export pipeline; see `rasterize-element-strategy.ts`. */
+    vectorSvgFallback?: RasterStrategyOptions['vectorSvgFallback'];
+    /** The per-binding `html2canvas-pro` driver, last resort. */
+    html2canvasFallback: RasterStrategyOptions['html2canvasFallback'];
+    /** Called whenever a strategy is attempted and fails, for diagnostics/telemetry. */
+    onStrategyFailed?: RasterStrategyOptions['onStrategyFailed'];
+    /** Called after each tile finishes, for progress UI on large tiled exports. */
+    onTileProgress?: (done: number, total: number) => void;
+}
+/** The common case: a normal canvas any `toBlob`/`toDataURL` caller can use directly. */
+export interface RasterizeElementCanvasResult {
+    kind: 'canvas';
+    canvas: HTMLCanvasElement;
+    strategy: RasterStrategy;
+    width: number;
+    height: number;
+}
+/** The tiled case: pre-encoded PNG bytes, since no single canvas held the full image. */
+export interface RasterizeElementPngBytesResult {
+    kind: 'png-bytes';
+    bytes: Uint8Array;
+    width: number;
+    height: number;
+    /** Strategy used per tile, in row-major order, for diagnostics/tests. */
+    strategies: RasterStrategy[];
+}
+export type RasterizeElementResult = RasterizeElementCanvasResult | RasterizeElementPngBytesResult;
+/**
+ * Rasterise `element` (an attached, `naturalWidth` x `naturalHeight` CSS-pixel
+ * stage) at `options.scale`, tiling transparently if the requested
+ * resolution exceeds the browser's canvas cap.
+ */
+export declare function rasterizeElement(element: HTMLElement, naturalWidth: number, naturalHeight: number, doc: Document, options: RasterizeElementOptions): Promise<RasterizeElementResult>;
+//# sourceMappingURL=rasterize-element.d.ts.map

package/dist/pptx/export/rasterize-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterize-element.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/rasterize-element.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAyB1F,uDAAuD;AACvD,MAAM,WAAW,uBAAuB;IACvC,oFAAoF;IACpF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qEAAqE;IACrE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0FAA0F;IAC1F,IAAI,CAAC,EAAE,qBAAqB,CAAC,MAAM,CAAC,CAAC;IACrC,+FAA+F;IAC/F,iBAAiB,CAAC,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,CAAC;IAC/D,6DAA6D;IAC7D,mBAAmB,EAAE,qBAAqB,CAAC,qBAAqB,CAAC,CAAC;IAClE,oFAAoF;IACpF,gBAAgB,CAAC,EAAE,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;IAC7D,+EAA+E;IAC/E,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACvD;AAED,yFAAyF;AACzF,MAAM,WAAW,4BAA4B;IAC5C,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,cAAc,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,yFAAyF;AACzF,MAAM,WAAW,8BAA8B;IAC9C,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,UAAU,EAAE,cAAc,EAAE,CAAC;CAC7B;AAED,MAAM,MAAM,sBAAsB,GAAG,4BAA4B,GAAG,8BAA8B,CAAC;AAgCnG;;;;GAIG;AACH,wBAAsB,gBAAgB,CACrC,OAAO,EAAE,WAAW,EACpB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,QAAQ,EACb,OAAO,EAAE,uBAAuB,GAC9B,OAAO,CAAC,sBAAsB,CAAC,CA4BjC"}

package/dist/pptx/export/rasterize-foreign-object.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Draw one already-assembled `foreignObject` SVG string (see
+ * `render/foreign-object-svg-document.ts`) onto a canvas via an `Image`
+ * element. This is the actual "browser rasterises the foreignObject" step:
+ * loading the self-contained SVG as an image and drawing it lets the
+ * browser's real layout/paint engine produce the pixels, which is what
+ * preserves `backdrop-filter`, CSS custom properties and 3D transforms that
+ * html2canvas's own renderer cannot.
+ *
+ * Every image reference inside the SVG must already be a `data:` URI
+ * ({@link embedImagesOnClone} in the document builder) for this to succeed:
+ * an SVG image that itself references a live cross-origin URL taints the
+ * canvas, so this module verifies the draw actually produced readable pixels
+ * (a 1x1 `getImageData` probe) and throws a typed error the caller can catch
+ * to fall back, rather than silently shipping a blank/erroring export.
+ *
+ * The SVG is handed to the `Image` as a `data:` URL, never a `blob:` object
+ * URL: measured in Chromium (`e2e/export-raster-fidelity.spec.ts`'s
+ * diagnosis, 2026-09), the very same `foreignObject` markup with zero
+ * external references draws CLEAN from a `data:` URL but TAINTS the canvas
+ * when loaded through `URL.createObjectURL`, which silently pushed every
+ * export onto the html2canvas fallback. This is the same reason
+ * `html-to-image`/`dom-to-image` use `data:` URLs.
+ */
+/** Thrown when the canvas could not be read back after drawing (taint, or a load failure). */
+export declare class ForeignObjectRasterError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+/** The `data:` URL prefix every foreignObject raster image is loaded from. */
+export declare const FOREIGN_OBJECT_SVG_DATA_URL_PREFIX = "data:image/svg+xml;charset=utf-8,";
+/** Encode one wrapped SVG string as the `data:` URL an `Image` can load. */
+export declare function foreignObjectSvgToDataUrl(svg: string): string;
+/**
+ * Rasterise one wrapped SVG string (a single export tile, or the whole
+ * slide for the non-tiled case) onto a new canvas sized `outputWidth` x
+ * `outputHeight` (the SVG's own `width`/`height` attributes, set by
+ * `wrapForeignObjectSvg`, should already match).
+ *
+ * @throws {ForeignObjectRasterError} if the image fails to load, no 2D
+ *   context is available, or the resulting canvas cannot be read back
+ *   (tainted by an un-embeddable cross-origin resource).
+ */
+export declare function rasterizeForeignObjectSvg(svg: string, outputWidth: number, outputHeight: number, backgroundColor?: string): Promise<HTMLCanvasElement>;
+//# sourceMappingURL=rasterize-foreign-object.d.ts.map

package/dist/pptx/export/rasterize-foreign-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterize-foreign-object.d.ts","sourceRoot":"","sources":["../../../src/pptx/export/rasterize-foreign-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,8FAA8F;AAC9F,qBAAa,wBAAyB,SAAQ,KAAK;aAGjC,KAAK,CAAC,EAAE,OAAO;IAFhC,YACC,OAAO,EAAE,MAAM,EACC,KAAK,CAAC,EAAE,OAAO,EAI/B;CACD;AAYD,8EAA8E;AAC9E,eAAO,MAAM,kCAAkC,sCAAsC,CAAC;AAEtF,4EAA4E;AAC5E,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC9C,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,eAAe,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,iBAAiB,CAAC,CA0B5B"}