pptx-renderer

A high-fidelity, browser-native PPTX renderer that parses Office Open XML (.pptx) files and renders slides as HTML/SVG DOM.

Supports shapes, text, images, tables, charts, SmartArt, groups, backgrounds, gradients, pattern fills, and the full OOXML color pipeline — covering the vast majority of real-world PowerPoint content.

Rendering Example

A complex slide with charts, text styles, shapes, and SmartArt — PowerPoint ground truth vs browser-rendered output:

Visual Regression Testing

Every rendering capability is automatically verified against PowerPoint output. 452+ visual regression cases with zero failures — covering 187+ preset shapes, 134+ SmartArt layouts, 36+ fill/stroke/gradient variants, and 101 python-pptx cases (text, shape adjustments, composites, charts).

E2E evaluation dashboard: side-by-side ground truth vs rendered output with SSIM, color histogram, and IoU metrics per slide.

Ground truth data (PPTX + PDF pairs) is not committed to the repository due to file size. It can be regenerated locally via scripts/one_shot_full_ground_truth.py with Microsoft PowerPoint installed (macOS and Windows both supported) — see docs/TESTING.md for details.

Install

npm install @aiden0z/pptx-renderer
# or
pnpm add @aiden0z/pptx-renderer

# Optional: only needed for SmartArt / EMF files with embedded PDF fallback previews
pnpm add pdfjs-dist

Requires Node.js 20+ for development. Runtime is browser-only.

Quick Start

import { PptxViewer, RECOMMENDED_ZIP_LIMITS } from '@aiden0z/pptx-renderer';

const container = document.getElementById('pptx-container')!;
const resp = await fetch('/slides/demo.pptx');

// One-liner: parse, build model, and render
const viewer = await PptxViewer.open(await resp.arrayBuffer(), container, {
  zipLimits: RECOMMENDED_ZIP_LIMITS,
  listOptions: { windowed: true },
});

For large decks, combine windowed mounting with on-demand slide parsing and media decoding:

const viewer = await PptxViewer.open(buffer, container, {
  zipLimits: RECOMMENDED_ZIP_LIMITS,
  lazySlides: true,
  lazyMedia: true,
  listOptions: { windowed: true, initialSlides: 4, batchSize: 4 },
});

Optional PDF.js Fallback for SmartArt/EMF Preview Images

PowerPoint often stores SmartArt or pasted vector artwork as EMF fallback images. This library does not implement a full EMF/WMF vector renderer. It can render the common Office fallback cases where an EMF contains an embedded PDF preview or bitmap preview.

For EMF files with embedded PDF previews, install pdfjs-dist and pass explicit asset URLs. This keeps PDF.js optional and avoids forcing every consumer bundle to include it. This is only needed for EMF-PDF fallback previews; ordinary PPTX rendering does not require any code changes.

import { PptxViewer } from '@aiden0z/pptx-renderer';

const pdfjs = {
  moduleUrl: new URL('pdfjs-dist/build/pdf.min.mjs', import.meta.url).toString(),
  workerUrl: new URL('pdfjs-dist/build/pdf.worker.min.mjs', import.meta.url).toString(),
};

const viewer = await PptxViewer.open(buffer, container, {
  pdfjs,
});

If your app uses a CDN or pre-copied assets, point those fields at your hosted files. Set pdfjs: false to disable EMF-PDF fallback rendering entirely. With no pdfjs configuration, the renderer attempts only a best-effort automatic resolution and otherwise degrades gracefully.

type PdfjsConfig =
  | {
      moduleUrl?: string;
      workerUrl?: string;
    }
  | false;

Or with more control over each step:

import {
  PptxViewer,
  parseZip,
  buildPresentation,
  RECOMMENDED_ZIP_LIMITS,
} from '@aiden0z/pptx-renderer';

const container = document.getElementById('pptx-container')!;
const viewer = new PptxViewer(container, { fitMode: 'contain' });

const files = await parseZip(arrayBuffer, RECOMMENDED_ZIP_LIMITS);
const presentation = buildPresentation(files);
viewer.load(presentation);
await viewer.renderList({ windowed: true, batchSize: 8 });

To delay both media decompression and slide node parsing until rendered slides actually need them, use parseZipLazyMedia() and pass { lazySlides: true } to buildPresentation():

import {
  PptxViewer,
  parseZipLazyMedia,
  buildPresentation,
  RECOMMENDED_ZIP_LIMITS,
} from '@aiden0z/pptx-renderer';

const files = await parseZipLazyMedia(arrayBuffer, RECOMMENDED_ZIP_LIMITS);
const presentation = buildPresentation(files, { lazySlides: true });

const viewer = new PptxViewer(container);
viewer.load(presentation);
await viewer.renderList({ windowed: true, initialSlides: 4 });

API

PptxViewer (primary, extends EventTarget)

PptxViewer.open(input, container, options?) — Static Factory

Parse, build, and render in one call. Returns a Promise<PptxViewer>.

const viewer = await PptxViewer.open(buffer, container, {
  renderMode: 'list', // 'list' (default) | 'slide'
  zipLimits: RECOMMENDED_ZIP_LIMITS,
  listOptions: { windowed: true, batchSize: 8 },
  signal: abortController.signal, // optional AbortSignal
  // ...ViewerOptions
});

new PptxViewer(container, options?)

| Option | Type | Default | Description | | ------------------ | -------------------------- | ----------- | ----------------------------------------------------------------------------------------------------------------- | | width | number | -- | Container width hint (omit for auto-detect) | | fitMode | 'contain' \| 'none' | 'contain' | Responsive fit or fixed size | | zoomPercent | number | 100 | Zoom level (10–400) | | scrollContainer | HTMLElement | -- | Scroll container for IntersectionObserver root | | zipLimits | ZipParseLimits | -- | Security limits for ZIP parsing (used by .open()). Use RECOMMENDED_ZIP_LIMITS for untrusted input. | | lazyMedia | boolean | false | Decode embedded media on demand instead of during ZIP parsing. Best for large decks with windowed list rendering. | | lazySlides | boolean | false | Parse slide shape/table/chart nodes on demand. Best for large decks with windowed list rendering. | | pdfjs | PdfjsConfig | -- | Optional PDF.js URLs for EMF-embedded PDF fallback rendering, or false to disable it. | | onSlideChange | (index) => void | -- | Shorthand for slidechange event | | onSlideRendered | (index, element) => void | -- | Shorthand for sliderendered event | | onSlideError | (index, error) => void | -- | Shorthand for slideerror event | | onSlideUnmounted | (index) => void | -- | Shorthand for slideunmounted event | | onNodeError | (nodeId, error) => void | -- | Shorthand for nodeerror event | | onRenderStart | () => void | -- | Shorthand for renderstart event | | onRenderComplete | () => void | -- | Shorthand for rendercomplete event |

All shorthand callbacks are also available as EventTarget events (e.g. viewer.addEventListener('slidechange', ...)).

Instance Methods

viewer.load(presentation);                              // Load a PresentationData model (no render)
await viewer.renderList({ windowed: true });             // Render all slides in scrollable list
await viewer.renderSlide(0);                             // Render a single slide (no built-in nav UI)

// Load from binary input (parse → build → render). Cleans up previous state on re-open.
await viewer.open(buffer, { renderMode: 'list', signal: abortController.signal });

await viewer.goToSlide(index);                           // Jump to slide (0-based), returns Promise<void>
await viewer.goToSlide(index, { behavior: 'instant' }); // Custom ScrollIntoViewOptions (list mode)
await viewer.setZoom(150);                               // Runtime zoom (10–400)
await viewer.setFitMode('none');                         // Switch fit mode
const matches = viewer.searchText('GPU');                 // Search parsed model text
const hit = await viewer.highlightSearchResult(matches[0]); // Default node overlay highlight
hit?.dispose();
viewer.clearSearchHighlights();                          // Remove active search overlays

// Render a single slide into an external container (React/Vue integration, thumbnails).
// Returns a SlideHandle; caller owns it and must call handle.dispose() when done.
const handle = viewer.renderSlideToContainer(index, container, scale?);
handle.dispose();                                        // Clean up slide-specific resources

// Render a lightweight scaled slide preview into an external container.
// This preserves the original slide layout and uses transform scaling; it is
// not a bitmap thumbnail generator, so use lazy/windowed mounting for decks.
const thumb = viewer.renderThumbnailToContainer(index, sidebarItem, { width: 180 });
await thumb?.ready;
thumb?.dispose();

// Query which slides are currently mounted in the DOM
viewer.isSlideMounted(index);   // boolean
viewer.getMountedSlides();      // number[] (sorted)

// Typed event helpers (return `this` for chaining)
viewer.on('slidechange', (e) => console.log(e.detail.index));
viewer.off('slidechange', listener);

viewer.destroy();               // Cleanup blob URLs, observers, and DOM
viewer[Symbol.dispose]();       // TC39 Explicit Resource Management (calls destroy)

Text Search

PptxViewer.searchText(query, options?) searches the parsed PresentationData model, not the rendered DOM. This keeps search available before or after a slide is mounted and avoids mutating renderer-generated text runs.

String queries are case-insensitive by default. Pass matchCase: true when you need exact casing. RegExp queries keep their own flags, so /GPU/ remains case-sensitive and /GPU/i remains case-insensitive.

import type { TextSearchResult } from '@aiden0z/pptx-renderer';

const matches: TextSearchResult[] = viewer.searchText('GPU', {
  matchCase: false,
  wholeWord: true,
  snippetRadius: 48,
});

const exactMatches = viewer.searchText('GPU', { matchCase: true });
const regexMatches = viewer.searchText(/GPU|CPU/i);

for (const match of matches) {
  await viewer.goToSlide(match.slideIndex, { behavior: 'smooth', block: 'center' });
  // Use match.bounds for node-level highlight overlays in your own UI.
}

Each TextSearchResult includes slideIndex, nodeId, nodePath, nodeType, textKind, full text, matchStart, matchEnd, snippet, and bounds. bounds is the matched shape or table bounds in intrinsic slide coordinates, so application code can draw node-level highlight overlays on top of a rendered slide.

The renderer intentionally does not rewrite text nodes for character-level text highlighting. Character-level text highlighting would require mapping match offsets back to shaped Office text runs and line layout, which is a separate, higher-risk renderer feature. Today the stable API boundary is model-level search plus node-level bounds.

For the common UI case, highlightSearchResult(result, options?) draws a node-level overlay using a default highlight style. Pass SearchHighlightOptions for custom colors, spacing, shadows, and class names:

const hit = await viewer.highlightSearchResult(matches[0], {
  className: 'my-search-hit',
  borderColor: '#22c55e',
  backgroundColor: 'rgba(34, 197, 94, 0.18)',
  borderRadius: 6,
  borderWidth: 2,
  boxShadow: '0 0 0 2px rgba(15, 23, 42, 0.35)',
  padding: 3,
});

// The caller owns returned highlight handles.
hit?.dispose();
viewer.clearSearchHighlights();

Scaled Slide Previews

PptxViewer.renderThumbnailToContainer(index, container, options?) renders a slide at its intrinsic layout size and applies CSS transform scaling inside a clipped wrapper. This avoids the layout drift that can happen if a PPTX slide is rendered directly into a small thumbnail-sized container.

const thumb = viewer.renderThumbnailToContainer(slideIndex, thumbnailEl, { width: 96 });
await thumb?.ready;

// The caller owns externally rendered previews.
thumb?.dispose();

This is not a bitmap thumbnail generator: it still creates a scaled DOM/SVG slide preview, so large decks should mount previews lazily with IntersectionObserver or a windowed list and dispose handles when they scroll out of view.

ListRenderOptions

| Option | Type | Default | Description | | ------------------ | --------- | ------- | ---------------------------------- | | windowed | boolean | false | Use IntersectionObserver windowing | | batchSize | number | 12 | Slides per render batch | | initialSlides | number | 4 | Initial slides to mount (windowed) | | overscanViewport | number | 1.5 | Viewport overscan multiplier |

ZipParseLimits and Resource Safety

parseZip(buffer) defaults to no ZIP limits for backward compatibility. For files from users or other untrusted sources, pass RECOMMENDED_ZIP_LIMITS or stricter values:

| Limit | Recommended value | What it protects | | --------------------------- | ----------------- | ------------------------------------------- | | maxEntries | 4000 | Archives with excessive file counts | | maxEntryUncompressedBytes | 32 MiB | A single oversized XML/media entry | | maxTotalUncompressedBytes | 256 MiB | Total decompressed archive size | | maxMediaBytes | 192 MiB | Total media payload size under ppt/media/ | | maxConcurrency | 8 | Parallel ZIP entry reads |

When ZIP metadata does not expose a reliable uncompressed size, the parser falls back to the actual decoded entry size before accepting the entry. This keeps maxEntryUncompressedBytes, maxTotalUncompressedBytes, and maxMediaBytes effective for XML/text entries and media entries alike.

Renderer-level guards also apply after ZIP parsing:

• Chart caches do not allocate from oversized c:ptCount; chart point indexes are capped at 10,000 per cache.
• EMF bitmap previews are rejected when decoded size exceeds 16,777,216 pixels, dimensions exceed 8192x8192, or pixel payload is shorter than the declared bitmap.
• External audio/video relationships only render for safe http/https URLs with TargetMode="External" and are created with preload="none".

Events (PptxViewerEventMap)

viewer.addEventListener('renderstart', () => {
  /* render cycle began */
});
viewer.addEventListener('rendercomplete', () => {
  /* render cycle finished (fires even on error) */
});
viewer.addEventListener('slidechange', (e) => console.log(e.detail.index));
viewer.addEventListener('sliderendered', (e) => console.log(e.detail.index, e.detail.element));
viewer.addEventListener('slideerror', (e) => console.error(e.detail.index, e.detail.error));
viewer.addEventListener('slideunmounted', (e) => console.log(e.detail.index));
viewer.addEventListener('nodeerror', (e) => console.warn(e.detail.nodeId, e.detail.error));

slidechange fires both on goToSlide() navigation and after each render cycle (initial render included). renderstart/rendercomplete bracket every render cycle (renderList, renderSlide, setZoom, setFitMode). When calls overlap, the newer render request supersedes older queued or batched work, so stale list batches stop before appending more DOM.

Instance Properties (read-only)

viewer.presentationData; // PresentationData | null — the parsed model, null before load()
viewer.slideCount; // number — total slides (0 if not loaded)
viewer.slideWidth; // number — intrinsic slide width in px
viewer.slideHeight; // number — intrinsic slide height in px
viewer.currentSlideIndex; // number — currently active slide (0-based)
viewer.isRendering; // boolean — true between renderstart and rendercomplete
viewer.zoomPercent; // number — current zoom level (e.g. 100, 200)
viewer.fitMode; // FitMode — current fit mode ('contain' | 'none')

PptxRenderer (deprecated v1 compat)

PptxRenderer extends PptxViewer and provides the legacy preview(input) API with built-in nav buttons in slide mode. Migrate to PptxViewer for new code.

import { PptxRenderer } from '@aiden0z/pptx-renderer';

const renderer = new PptxRenderer(container, { mode: 'list', listMountStrategy: 'windowed' });
await renderer.preview(buffer); // deprecated — use PptxViewer.open() instead

PptxRenderer accepts the same optional lazyMedia, lazySlides, and pdfjs configuration as PptxViewer, so legacy users can enable performance options or EMF-PDF fallback rendering without changing APIs.

Utility Exports

import {
  parseZip,
  parseZipLazyMedia,
  buildPresentation,
  materializeAllSlideNodes,
  serializePresentation,
  buildTextIndex,
  searchText,
  searchPresentation,
  RECOMMENDED_ZIP_LIMITS,
} from '@aiden0z/pptx-renderer';

const files = await parseZip(arrayBuffer, RECOMMENDED_ZIP_LIMITS); // PptxFiles
const lazyFiles = await parseZipLazyMedia(arrayBuffer, RECOMMENDED_ZIP_LIMITS); // media resolves on demand
const presentation = buildPresentation(files); // PresentationData
const lazyPresentation = buildPresentation(lazyFiles, { lazySlides: true }); // slide nodes parse on demand
materializeAllSlideNodes(lazyPresentation); // optional: force full model materialization
const json = serializePresentation(presentation); // SerializedPresentation (JSON-safe)
const index = buildTextIndex(presentation); // TextIndexEntry[]
const matches = searchText(index, '算力'); // TextSearchResult[]
const directMatches = searchPresentation(presentation, /GPU|CPU/i); // TextSearchResult[]

Headless Slide Rendering

For advanced use cases (server-side screenshot, custom rendering pipeline):

import { renderSlide } from '@aiden0z/pptx-renderer';
import type { SlideHandle } from '@aiden0z/pptx-renderer';

const handle = renderSlide(presentation, presentation.slides[0], {
  onNodeError: (nodeId, err) => console.warn(nodeId, err),
  mediaUrlCache: new Map(), // optional shared cache for blob URLs
  pdfjs, // optional, only for EMF-embedded PDF fallback rendering
});
document.body.appendChild(handle.element);

// Await async media such as EMF-PDF fallback previews before screenshots/exports.
await handle.ready;

// Clean up when done (disposes charts + blob URLs in standalone mode)
handle.dispose();

Model Types

All model types are exported for consumers building custom tooling:

import type {
  PresentationData,
  BuildPresentationOptions,
  SlideData,
  SlideNode,
  ThemeData,
  BaseNodeData,
  ShapeNodeData,
  PicNodeData,
  TableNodeData,
  GroupNodeData,
  ChartNodeData,
  TextBody,
  TextParagraph,
  TextRun,
  Position,
  Size,
  NodeType,
  SerializedPresentation,
  SerializedSlide,
  SerializedNode,
  PptxFiles,
  ZipParseLimits,
  FitMode,
  PreviewInput,
  ViewerOptions,
  ListRenderOptions,
  ThumbnailRenderOptions,
  SearchHighlightHandle,
  SearchHighlightOptions,
  PptxViewerEventMap,
  SlideHandle,
  PdfjsOptions,
  PdfjsConfig,
  TextBounds,
  TextIndexEntry,
  TextIndexOptions,
  TextSearchOptions,
  TextSearchResult,
} from '@aiden0z/pptx-renderer';

Rendering Capabilities

Shapes — 187+ Presets + Custom Geometry

All commonly used OOXML DrawingML preset shapes, organized by category:

| Category | Count | Highlights | | ----------------- | ----: | -------------------------------------------------------------- | | Basic & Geometric | 70 | Rectangles, ovals, polygons, stars, arcs, clouds, gears, etc. | | Flowchart | 30 | All standard flowchart shapes | | Arrows | 22 | Directional, bent, curved, striped, chevron | | Stars & Banners | 17 | N-point stars, explosions, ribbons, scrolls | | Callouts | 17 | Rectangular, rounded, oval, cloud, line callout variants | | Connectors | 12 | Straight, bent, curved (2-5 segments) | | Action Buttons | 9 | Multi-path 3D with darken/lighten face modifiers | | Math & Brackets | 12 | Plus, minus, multiply, division, brackets, braces | | Multi-path 3D | 33+ | Bevel, cube, can, ribbons — multi-layer SVG with 3D appearance |

Custom geometry (<a:custGeom>) is also supported via a general-purpose OOXML path interpreter.

Text — 7-Level Style Inheritance

Full OOXML text cascade: master → layout → shape → paragraph → run. Supports theme fonts, numbered/symbol/picture bullets, multi-level indent, vertical text, superscript/subscript, hyperlinks, and per-shape text insets.

Charts via ECharts

Powered by ECharts. Supports Bar/Column (clustered, stacked, 100% stacked), Line/Area (standard, stacked, 100% stacked), Pie, multi-ring Doughnut, Radar, Scatter, Bubble, and Stock/Candlestick charts, with axis labels, legends, data labels, grid lines, chart color-style palettes, marker symbols, and custom number formats.

OOXML 3D chart elements such as bar3DChart, line3DChart, pie3DChart, area3DChart, and surface3DChart are parsed as graceful 2D fallbacks where possible. True 3D perspective, depth walls, and surface meshes are not PowerPoint-perfect.

Fill, Stroke & Color

• Fills: solid, linear/radial/rectangular gradient, 52+ pattern fills, image (stretch/tile)
• Strokes: 8 dash styles, 5 arrowhead types, compound lines, line joins
• Colors: full OOXML pipeline — schemeClr → colorMap remap → theme lookup → modifiers (lumMod, lumOff, tint, shade, alpha, satMod, etc.). All 6 color spaces supported.

SmartArt, Tables, Images & More

• SmartArt: 134+ layouts via PowerPoint fallback data. EMF-embedded PDF previews can be rendered with optional pdfjs-dist configuration.
• Tables: OOXML table styles, cell merge, border inheritance
• Images: blob URL with crop, stretch/tile, video/audio placeholders
• Groups: coordinate remapping with recursive child rendering
• Backgrounds: slide → layout → master inheritance chain

Architecture

Three-layer pipeline: Parse -> Model -> Render

ArrayBuffer (.pptx)
  -> ZipParser (jszip extraction)
  -> XmlParser (DOMParser + SafeXmlNode null-safe wrapper)
  -> buildPresentation() (assembles slides/layouts/masters/themes with relationship chains)
  -> SlideRenderer (background -> master shapes -> layout shapes -> slide shapes -> DOM)

Key design decisions:

• SafeXmlNode: Null-safe XML traversal — returns empty nodes instead of null, enabling deep chaining without null checks.
• Lazy slide parsing: Optional lazySlides mode keeps per-slide nodes deferred until render, search, serialization, or explicit materialization.
• Lazy group parsing: Group children stored as raw XML, parsed during rendering to avoid deep recursion in model layer.
• Error isolation: Per-node try/catch. A failed shape renders as a dashed-red placeholder; the slide continues.
• No external CSS: All styles inline. The library outputs self-contained HTML fragments.
• Blob URL lifecycle: Created for images/media, tracked in mediaUrlCache, revoked on destroy().

Performance

The default behavior stays eager for compatibility: parse the package, build the full model, and render according to the selected mode. For large or media-heavy decks, opt into the lazy/windowed path so the first visible slides can render without materializing every slide and every media entry up front.

Use this preset for interactive viewers:

const viewer = await PptxViewer.open(buffer, container, {
  zipLimits: RECOMMENDED_ZIP_LIMITS,
  lazySlides: true,
  lazyMedia: true,
  listOptions: {
    windowed: true,
    batchSize: 8,
    initialSlides: 4,
    overscanViewport: 1.5,
  },
});

Recommended choices:

| Scenario | Recommended options | Main benefit | | ------------------------------------- | ------------------------------------------------------- | -------------------------------------------- | | User-uploaded PPTX | zipLimits: RECOMMENDED_ZIP_LIMITS | Bounds ZIP parsing work and decoded payloads | | Long scrollable viewer | listOptions.windowed: true | Keeps off-screen slides out of the DOM | | Large decks with many slide elements | lazySlides: true plus windowed list rendering | Defers per-slide node parsing until needed | | Media-heavy decks | lazyMedia: true plus windowed list rendering | Defers image/audio/video byte decoding | | Export, print, or full comparison job | Eager defaults, or explicitly materialize before export | Ensures all slides are ready in one pass |

In local benchmarks, lazySlides reduced model build time by roughly 52-66% on medium and large decks, and lowered first-window parse + build + render time by roughly 16-22%. For media-heavy windowed viewers, lazyMedia reduced initially decompressed media bytes by about 72-97%, depending on deck content. These options preserve rendering semantics; they mainly move work from initial load to the moment a slide or media item is actually needed.

Manual pipelines can use the same building blocks:

const files = await parseZipLazyMedia(buffer, RECOMMENDED_ZIP_LIMITS);
const presentation = buildPresentation(files, { lazySlides: true });

const viewer = new PptxViewer(container);
viewer.load(presentation);
await viewer.renderList({ windowed: true, initialSlides: 4 });

Details: docs/PERFORMANCE.md

Security

• Treat PPTX input as untrusted. Start with RECOMMENDED_ZIP_LIMITS, then tighten for your deployment.
• External hyperlinks are protocol-filtered (no javascript:, data:, etc.).
• Reporting: docs/SECURITY.md

Development

pnpm install
pnpm dev          # Vite dev server
pnpm test         # Unit tests (vitest)
pnpm test:coverage # Coverage report → coverage/
pnpm build        # Production build
pnpm dev:e2e      # Dev server + Python E2E API server
pnpm lint         # ESLint
pnpm typecheck    # tsc --noEmit
pnpm knip         # Dead code / unused exports detection

Dev pages at http://127.0.0.1:5173:

| Page | Purpose | | ------------------------------- | ----------------------------------------- | | /test/pages/index.html | Upload preview with search and thumbnails | | /test/pages/render-slide.html | Single slide at native resolution | | /test/pages/e2e-compare.html | Side-by-side PDF vs HTML with SSIM scores | | /test/pages/export.html | Model JSON tree viewer |

Documentation

| Doc | Content | | ----------------------------------------- | ---------------------------------------------------------------------- | | ARCHITECTURE.md | Parse/model/render pipeline design | | PERFORMANCE.md | Tuning options and presets | | TESTING.md | Unit/E2E strategy, two-layer metric system, visual regression workflow | | CONTRIBUTING.md | PR checklist, code quality tools, and workflow | | SECURITY.md | Vulnerability reporting |

What's Not Yet Supported

3D effects, true 3D chart perspective/depth/surface meshes, animations/transitions, equations (OMML), full EMF/WMF vector rendering, shadow/reflection/glow effects, embedded OLE objects, and slide notes rendering.

FAQ

Does this run on Node.js? No. Rendering depends on browser DOM APIs.

Why is my PPTX rendering incomplete? OOXML is a vast spec. Please open a compatibility issue with a minimal PPTX sample — the visual regression pipeline makes it straightforward to add coverage for new cases.

How do I render 100+ slide decks efficiently? Use windowed: true in listOptions, and enable lazySlides: true. For media-heavy decks, also enable lazyMedia: true.

License

Apache License 2.0. See LICENSE.