@extend-ai/react-pptx 0.1.1 → 0.2.0

package/dist/index.js

@@ -9247,8 +9247,71 @@ var EMU_PER_CSS_PIXEL = 9525;
 var DEFAULT_TEXT_HORIZONTAL_INSET_EMU = 91440;
 var DEFAULT_TEXT_VERTICAL_INSET_EMU = 45720;
 var POWERPOINT_SINGLE_LINE_HEIGHT = 1.15;
+var PresentationAssetCache = class {
+  references = 0;
+  objectUrls = /* @__PURE__ */ new Set();
+  assetUrls = /* @__PURE__ */ new Map();
+  metafileUrls = /* @__PURE__ */ new Map();
+  acquire() {
+    this.references += 1;
+    return this;
+  }
+  metafileUrl(assetId, contentType, data) {
+    const cached = this.metafileUrls.get(assetId);
+    if (cached) return cached;
+    const convert = contentType.includes("wmf") ? renderWmfToDataUrl : renderEmfToDataUrl;
+    const ownedBytes = data.slice();
+    const pending = convert(ownedBytes.buffer, 2048, 2048, {
+      dpiScale: 2,
+      maxCanvasDimension: 4096,
+      maxRecords: 2e5,
+      fontFamilyMap: METAFILE_FONT_MAP
+    }).then((url) => url || void 0);
+    this.metafileUrls.set(assetId, pending);
+    return pending;
+  }
+  assetUrl(asset) {
+    if (asset.url) return Promise.resolve(asset.url);
+    if (!asset.data) return Promise.resolve(void 0);
+    const contentType = asset.contentType.toLowerCase();
+    if (contentType.includes("emf") || contentType.includes("wmf")) {
+      return this.metafileUrl(asset.id, contentType, asset.data);
+    }
+    const cached = this.assetUrls.get(asset.id);
+    if (cached) return Promise.resolve(cached);
+    const ownedBytes = asset.data.slice();
+    const url = URL.createObjectURL(
+      new Blob([ownedBytes.buffer], { type: asset.contentType })
+    );
+    this.objectUrls.add(url);
+    this.assetUrls.set(asset.id, url);
+    return Promise.resolve(url);
+  }
+  release() {
+    this.references = Math.max(0, this.references - 1);
+    if (this.references > 0) return;
+    for (const url of this.objectUrls) URL.revokeObjectURL(url);
+    this.objectUrls.clear();
+    this.assetUrls.clear();
+    this.metafileUrls.clear();
+  }
+};
+var presentationAssetCaches = /* @__PURE__ */ new WeakMap();
+function acquirePresentationAssetCache(presentation) {
+  let cache = presentationAssetCaches.get(presentation);
+  if (!cache) {
+    cache = new PresentationAssetCache();
+    presentationAssetCaches.set(presentation, cache);
+  }
+  return cache.acquire();
+}
 var LIST_ITEM_GAP = 24;
 var FALLBACK_VIEWPORT_RECT = { width: 800, height: 600 };
+function scaleListAnchorOffset(offset, previousSlideHeight, nextSlideHeight) {
+  if (previousSlideHeight <= 0) return offset;
+  if (offset <= previousSlideHeight) return offset * (nextSlideHeight / previousSlideHeight);
+  return nextSlideHeight + (offset - previousSlideHeight);
+}
 var METAFILE_FONT_MAP = Object.fromEntries(
   Object.entries(OFFICE_FONT_FALLBACKS).map(([family, fallbacks]) => [
     family,
@@ -9783,6 +9846,7 @@ var NormalizedPresentationViewer = class {
     this.container = container;
     this.presentation = presentation;
     this.callbacks = callbacks;
+    this.assetCache = acquirePresentationAssetCache(presentation);
   }
   container;
   presentation;
@@ -9790,12 +9854,10 @@ var NormalizedPresentationViewer = class {
   current = 0;
   zoom = 100;
   fit = "contain";
-  objectUrls = /* @__PURE__ */ new Set();
-  assetUrls = /* @__PURE__ */ new Map();
-  metafileUrls = /* @__PURE__ */ new Map();
+  assetCache;
   listCleanup;
   highlight;
-  pendingResources = /* @__PURE__ */ new Set();
+  activeMountResources;
   mountedHandles = /* @__PURE__ */ new Set();
   handlesByTarget = /* @__PURE__ */ new Map();
   destroyed = false;
@@ -9826,6 +9888,10 @@ var NormalizedPresentationViewer = class {
     const height = this.presentation.size.heightEmu / EMU_PER_CSS_PIXEL;
     return Number.isFinite(height) && height > 0 ? height : 1;
   }
+  scaleForViewport(viewportWidth) {
+    const fitScale = this.fit === "contain" ? Math.min(1, (viewportWidth || this.naturalSlideWidth) / this.naturalSlideWidth) : 1;
+    return fitScale * (this.zoom / 100);
+  }
   isRenderActive(generation) {
     return !this.destroyed && generation === this.renderGeneration;
   }
@@ -9844,46 +9910,19 @@ var NormalizedPresentationViewer = class {
     this.lastNotifiedSlide = index;
     this.callbacks.onSlideChange?.(index);
   }
-  metafileUrl(assetId, contentType, data) {
-    const cached = this.metafileUrls.get(assetId);
-    if (cached) return cached;
-    const convert = contentType.includes("wmf") ? renderWmfToDataUrl : renderEmfToDataUrl;
-    const ownedBytes = data.slice();
-    const pending = convert(ownedBytes.buffer, 2048, 2048, {
-      dpiScale: 2,
-      maxCanvasDimension: 4096,
-      maxRecords: 2e5,
-      fontFamilyMap: METAFILE_FONT_MAP
-    }).then((url) => url || void 0);
-    this.metafileUrls.set(assetId, pending);
-    return pending;
-  }
   assetUrl(asset) {
-    if (asset.url) return Promise.resolve(asset.url);
-    if (!asset.data) return Promise.resolve(void 0);
-    const contentType = asset.contentType.toLowerCase();
-    if (contentType.includes("emf") || contentType.includes("wmf")) {
-      return this.metafileUrl(asset.id, contentType, asset.data);
-    }
-    const cached = this.assetUrls.get(asset.id);
-    if (cached) return Promise.resolve(cached);
-    const ownedBytes = asset.data.slice();
-    const url = URL.createObjectURL(
-      new Blob([ownedBytes.buffer], { type: asset.contentType })
-    );
-    this.objectUrls.add(url);
-    this.assetUrls.set(asset.id, url);
-    return Promise.resolve(url);
+    return this.assetCache.assetUrl(asset);
   }
   applyAsset(assetId, apply, nodeId) {
     const asset = this.presentation.assets[assetId];
     if (!asset) return;
+    const resources = this.activeMountResources;
     const pending = this.assetUrl(asset).then((url) => {
       if (url && !this.destroyed) apply(url);
     }).catch((error) => {
       if (!this.destroyed) this.callbacks.onNodeError?.(nodeId, error);
-    }).finally(() => this.pendingResources.delete(pending));
-    this.pendingResources.add(pending);
+    });
+    resources?.add(pending);
   }
   /**
    * Applies DrawingML picture recolor effects (`a:biLevel`, `a:grayscl`,
@@ -10039,11 +10078,7 @@ var NormalizedPresentationViewer = class {
       image.setAttribute("preserveAspectRatio", "none");
       image.setAttribute("clip-path", `url(#${clipId})`);
       image.style.opacity = String(Math.max(0, Math.min(1, fillStyle.opacity ?? 1)));
-      this.applyAsset(
-        fillStyle.assetId,
-        (url) => image.setAttribute("href", url),
-        node.id
-      );
+      this.applyAsset(fillStyle.assetId, (url) => image.setAttribute("href", url), node.id);
       svg.append(image);
     }
     if (node.line) {
@@ -10406,23 +10441,35 @@ var NormalizedPresentationViewer = class {
       element,
       target,
       ready: Promise.resolve(),
+      setScale: () => {
+      },
       dispose: () => element.remove()
     };
   }
   mount(index, target, scale) {
     if (this.destroyed) return this.emptyHandle(target);
     this.handlesByTarget.get(target)?.dispose();
-    const slide = this.createSlide(index);
-    const fitScale = this.fit === "contain" ? Math.min(1, (target.clientWidth || this.naturalSlideWidth) / this.naturalSlideWidth) : 1;
-    const effectiveScale = scale ?? fitScale * (this.zoom / 100);
+    const resources = /* @__PURE__ */ new Set();
+    const previousResources = this.activeMountResources;
+    this.activeMountResources = resources;
+    let slide;
+    try {
+      slide = this.createSlide(index);
+    } finally {
+      this.activeMountResources = previousResources;
+    }
+    const effectiveScale = scale ?? this.scaleForViewport(target.clientWidth);
     const wrapper = document.createElement("div");
     wrapper.dataset.rpvSlideWrapper = String(index);
     wrapper.style.position = "relative";
-    wrapper.style.width = `${this.naturalSlideWidth * effectiveScale}px`;
-    wrapper.style.height = `${this.naturalSlideHeight * effectiveScale}px`;
     wrapper.style.margin = "0 auto";
     slide.style.transformOrigin = "top left";
-    slide.style.transform = `scale(${effectiveScale})`;
+    const setScale = (nextScale) => {
+      wrapper.style.width = `${this.naturalSlideWidth * nextScale}px`;
+      wrapper.style.height = `${this.naturalSlideHeight * nextScale}px`;
+      slide.style.transform = `scale(${nextScale})`;
+    };
+    setScale(effectiveScale);
     wrapper.append(slide);
     target.replaceChildren(wrapper);
     this.callbacks.onSlideRendered?.(index, slide);
@@ -10430,7 +10477,8 @@ var NormalizedPresentationViewer = class {
     const handle = {
       element: slide,
       target,
-      ready: Promise.all([...this.pendingResources]).then(() => void 0),
+      ready: Promise.all([...resources]).then(() => void 0),
+      setScale,
       dispose: () => {
         if (disposed) return;
         disposed = true;
@@ -10458,6 +10506,32 @@ var NormalizedPresentationViewer = class {
       await Promise.resolve();
     }
   }
+  async yieldNavigationPaint() {
+    if (typeof requestAnimationFrame !== "undefined") {
+      await new Promise((resolve) => {
+        let settled = false;
+        let firstFrame;
+        let secondFrame;
+        const complete = () => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeout2);
+          if (typeof cancelAnimationFrame !== "undefined") {
+            if (firstFrame !== void 0) cancelAnimationFrame(firstFrame);
+            if (secondFrame !== void 0) cancelAnimationFrame(secondFrame);
+          }
+          resolve();
+        };
+        const timeout2 = setTimeout(complete, 100);
+        firstFrame = requestAnimationFrame(() => {
+          if (settled) return;
+          secondFrame = requestAnimationFrame(complete);
+        });
+      });
+    } else {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
   async mountInBatches(placeholders, indices, batchSize, generation) {
     const uniqueIndices = [...new Set(indices)].filter(
       (index) => index >= 0 && index < placeholders.length
@@ -10490,12 +10564,13 @@ var NormalizedPresentationViewer = class {
   createListPlaceholder(index, item, generation, scale) {
     let handle;
     let mountPromise;
+    let effectiveScale = scale;
     const isActive = () => this.isRenderActive(generation) && this.listState?.generation === generation;
     const mount = () => {
       if (!isActive()) return Promise.resolve();
       if (handle) return handle.ready;
       if (mountPromise) return mountPromise;
-      const nextHandle = this.mount(index, item, scale);
+      const nextHandle = this.mount(index, item, effectiveScale);
       handle = nextHandle;
       const pending = nextHandle.ready.then(() => {
         if (!isActive() || handle !== nextHandle) {
@@ -10511,11 +10586,16 @@ var NormalizedPresentationViewer = class {
     const unmount = () => {
       const mounted = handle;
       handle = void 0;
+      mountPromise = void 0;
       if (mounted) {
         mounted.dispose();
       }
     };
-    return { item, mount, unmount, isMounted: () => Boolean(handle) };
+    const setScale = (nextScale) => {
+      effectiveScale = nextScale;
+      handle?.setScale(nextScale);
+    };
+    return { item, mount, unmount, isMounted: () => Boolean(handle), setScale };
   }
   async renderList(options = {}) {
     const windowingEnabled = options.enabled !== false;
@@ -10539,11 +10619,9 @@ var NormalizedPresentationViewer = class {
       Math.min(this.slideCount - 1, options.initialSlideIndex ?? this.current)
     );
     const scroller = options.scrollElement ?? this.container;
-    const viewportWidth = scroller.clientWidth;
-    const estimatedFitScale = this.fit === "contain" ? Math.min(1, (viewportWidth || this.naturalSlideWidth) / this.naturalSlideWidth) : 1;
-    const effectiveScale = estimatedFitScale * (this.zoom / 100);
-    const slideHeight = this.naturalSlideHeight * effectiveScale;
-    const itemStride = slideHeight + LIST_ITEM_GAP;
+    let effectiveScale = this.scaleForViewport(scroller.clientWidth);
+    let slideHeight = this.naturalSlideHeight * effectiveScale;
+    let itemStride = slideHeight + LIST_ITEM_GAP;
     if (!windowingEnabled) {
       const placeholders2 = this.presentation.slides.map((_, index) => {
         const item = document.createElement("div");
@@ -10551,9 +10629,35 @@ var NormalizedPresentationViewer = class {
         item.style.minHeight = `${slideHeight}px`;
         item.style.margin = `0 auto ${LIST_ITEM_GAP}px`;
         this.container.append(item);
-        return this.createListPlaceholder(index, item, generation);
+        return this.createListPlaceholder(index, item, generation, effectiveScale);
       });
       const state2 = { generation, options: normalizedOptions, placeholders: placeholders2 };
+      state2.updateScale = () => {
+        if (!this.isRenderActive(generation) || this.listState !== state2) return;
+        const previousStride = itemStride;
+        const previousSlideHeight = slideHeight;
+        const listStart = scroller === this.container ? 0 : this.container.getBoundingClientRect().top - scroller.getBoundingClientRect().top + scroller.scrollTop;
+        const listOffset = scroller.scrollTop - listStart;
+        const anchorIndex = Math.max(
+          0,
+          Math.min(this.slideCount - 1, Math.floor(listOffset / previousStride))
+        );
+        const anchorOffset = listOffset - anchorIndex * previousStride;
+        effectiveScale = this.scaleForViewport(scroller.clientWidth);
+        slideHeight = this.naturalSlideHeight * effectiveScale;
+        itemStride = slideHeight + LIST_ITEM_GAP;
+        placeholders2.forEach((placeholder) => {
+          placeholder.item.style.minHeight = `${slideHeight}px`;
+          placeholder.setScale(effectiveScale);
+        });
+        if (listOffset < 0) return;
+        const nextAnchorOffset = scaleListAnchorOffset(
+          anchorOffset,
+          previousSlideHeight,
+          slideHeight
+        );
+        scroller.scrollTop = Math.max(0, listStart + anchorIndex * itemStride + nextAnchorOffset);
+      };
       this.listState = state2;
       await this.mountInBatches(
         placeholders2,
@@ -10595,6 +10699,20 @@ var NormalizedPresentationViewer = class {
     const state = { generation, options: normalizedOptions, placeholders };
     this.listState = state;
     const isActive = () => this.isRenderActive(generation) && this.listState === state;
+    const deferredMounts = /* @__PURE__ */ new Map();
+    let virtualWindow = /* @__PURE__ */ new Set();
+    state.deferMount = (index) => {
+      deferredMounts.set(index, (deferredMounts.get(index) ?? 0) + 1);
+    };
+    state.resumeMount = (index) => {
+      const remaining = (deferredMounts.get(index) ?? 0) - 1;
+      if (remaining > 0) {
+        deferredMounts.set(index, remaining);
+        return;
+      }
+      deferredMounts.delete(index);
+      if (virtualWindow.has(index)) void placeholders[index]?.mount();
+    };
     const measureViewportRect = () => {
       const rect = scroller.getBoundingClientRect();
       if (rect.width > 0 && rect.height > 0) return { width: rect.width, height: rect.height };
@@ -10606,16 +10724,25 @@ var NormalizedPresentationViewer = class {
     const initialRect = measureViewportRect();
     const requestedOverscan = options.overscanViewport ?? 1.5;
     const overscanViewports = Number.isFinite(requestedOverscan) && requestedOverscan >= 0 ? requestedOverscan : 1.5;
-    const overscan = Math.max(1, Math.ceil(overscanViewports * initialRect.height / itemStride));
+    let overscan = Math.max(1, Math.ceil(overscanViewports * initialRect.height / itemStride));
     const measureScrollMargin = () => sizer.getBoundingClientRect().top - scroller.getBoundingClientRect().top + scroller.scrollTop;
     let scrollMargin = measureScrollMargin();
     let needsSettleAlignment = initialIndex > 0;
     let lastProgrammaticTop;
+    const writeScrollTop = (top, behavior) => {
+      lastProgrammaticTop = top;
+      if (typeof scroller.scrollTo === "function") {
+        scroller.scrollTo(behavior ? { top, behavior } : { top });
+      } else {
+        scroller.scrollTop = top;
+      }
+    };
     const reconcile = (instance) => {
       if (!isActive()) return;
       const windowed = new Set(instance.getVirtualItems().map((item) => item.index));
+      virtualWindow = windowed;
       placeholders.forEach((placeholder, index) => {
-        if (windowed.has(index)) void placeholder.mount();
+        if (windowed.has(index) && !deferredMounts.has(index)) void placeholder.mount();
         else placeholder.unmount();
       });
       const offset = (instance.scrollOffset ?? 0) - scrollMargin;
@@ -10678,12 +10805,7 @@ var NormalizedPresentationViewer = class {
       },
       scrollToFn: (offset, { adjustments, behavior }) => {
         const top = offset + (adjustments ?? 0);
-        lastProgrammaticTop = top;
-        if (typeof scroller.scrollTo === "function") {
-          scroller.scrollTo(behavior ? { top, behavior } : { top });
-        } else {
-          scroller.scrollTop = top;
-        }
+        writeScrollTop(top, behavior);
       },
       onChange: (instance) => reconcile(instance)
     });
@@ -10694,6 +10816,39 @@ var NormalizedPresentationViewer = class {
         behavior: scrollOptions?.behavior === "smooth" ? "smooth" : "auto"
       });
     };
+    state.updateScale = () => {
+      if (!isActive()) return;
+      const previousStride = itemStride;
+      const previousSlideHeight = slideHeight;
+      const anchorIndex = this.current;
+      const observedScrollTop = virtualizer.scrollOffset ?? scroller.scrollTop;
+      const observedIndex = Math.floor((observedScrollTop - scrollMargin) / previousStride);
+      const intendedIndex = lastProgrammaticTop === void 0 ? void 0 : Math.floor((lastProgrammaticTop - scrollMargin) / previousStride);
+      const previousScrollTop = Math.abs(observedIndex - anchorIndex) > 1 && intendedIndex !== void 0 && Math.abs(intendedIndex - anchorIndex) <= 1 ? lastProgrammaticTop : observedScrollTop;
+      const previousOffset = previousScrollTop - scrollMargin;
+      const anchorOffset = previousOffset - anchorIndex * previousStride;
+      effectiveScale = this.scaleForViewport(scroller.clientWidth);
+      slideHeight = this.naturalSlideHeight * effectiveScale;
+      itemStride = slideHeight + LIST_ITEM_GAP;
+      sizer.style.height = `${this.slideCount * itemStride - LIST_ITEM_GAP}px`;
+      placeholders.forEach((placeholder, index) => {
+        placeholder.item.style.height = `${slideHeight}px`;
+        placeholder.item.style.transform = `translateY(${index * itemStride}px)`;
+        placeholder.setScale(effectiveScale);
+      });
+      const nextAnchorOffset = scaleListAnchorOffset(
+        anchorOffset,
+        previousSlideHeight,
+        slideHeight
+      );
+      const nextScrollTop = previousOffset < 0 ? previousScrollTop : Math.max(0, scrollMargin + anchorIndex * itemStride + nextAnchorOffset);
+      const viewportRect = measureViewportRect();
+      overscan = Math.max(1, Math.ceil(overscanViewports * viewportRect.height / itemStride));
+      virtualizer.scrollOffset = nextScrollTop;
+      writeScrollTop(nextScrollTop);
+      virtualizer.setOptions({ ...virtualizer.options, overscan });
+      virtualizer.measure();
+    };
     const teardown = virtualizer._didMount();
     this.listCleanup = teardown;
     virtualizer._willUpdate();
@@ -10721,16 +10876,27 @@ var NormalizedPresentationViewer = class {
     if (state && this.isRenderActive(state.generation)) {
       const navigation = ++this.navigationGeneration;
       const placeholder = state.placeholders[next];
-      await placeholder?.mount();
-      if (this.destroyed || navigation !== this.navigationGeneration || !this.isRenderActive(state.generation) || this.listState !== state) {
-        return;
-      }
-      if (changed) {
-        if (state.scrollToIndex) state.scrollToIndex(next, scrollOptions);
-        else placeholder?.item.scrollIntoView?.(scrollOptions);
+      let mountDeferred = Boolean(state.deferMount && placeholder && !placeholder.isMounted());
+      if (mountDeferred) state.deferMount?.(next);
+      try {
+        if (changed) {
+          if (state.scrollToIndex) state.scrollToIndex(next, scrollOptions);
+          else placeholder?.item.scrollIntoView?.(scrollOptions);
+          this.current = next;
+          this.notifySlideChange(next);
+        }
+        if (mountDeferred) await this.yieldNavigationPaint();
+        if (this.destroyed || navigation !== this.navigationGeneration || !this.isRenderActive(state.generation) || this.listState !== state) {
+          return;
+        }
+        if (mountDeferred) {
+          state.resumeMount?.(next);
+          mountDeferred = false;
+        }
+        await placeholder?.mount();
+      } finally {
+        if (mountDeferred) state.resumeMount?.(next);
       }
-      this.current = next;
-      if (changed) this.notifySlideChange(next);
       return;
     }
     if (!changed && this.container.querySelector(`[data-rpv-slide-index="${next}"]`)) return;
@@ -10741,15 +10907,33 @@ var NormalizedPresentationViewer = class {
     if (this.zoom === next) return;
     this.zoom = next;
     if (this.renderState?.mode === "continuous") {
-      await this.renderList({ ...this.renderState.options, initialSlideIndex: this.current });
-    } else if (this.renderState) await this.renderSlide(this.current);
+      const state = this.listState;
+      if (state && this.isRenderActive(state.generation) && state.updateScale) {
+        state.updateScale();
+      } else {
+        await this.renderList({ ...this.renderState.options, initialSlideIndex: this.current });
+      }
+    } else if (this.renderState) {
+      const handle = this.handlesByTarget.get(this.container);
+      if (handle) handle.setScale(this.scaleForViewport(this.container.clientWidth));
+      else await this.renderSlide(this.current);
+    }
   }
   async setFitMode(mode) {
     if (this.fit === mode) return;
     this.fit = mode;
     if (this.renderState?.mode === "continuous") {
-      await this.renderList({ ...this.renderState.options, initialSlideIndex: this.current });
-    } else if (this.renderState) await this.renderSlide(this.current);
+      const state = this.listState;
+      if (state && this.isRenderActive(state.generation) && state.updateScale) {
+        state.updateScale();
+      } else {
+        await this.renderList({ ...this.renderState.options, initialSlideIndex: this.current });
+      }
+    } else if (this.renderState) {
+      const handle = this.handlesByTarget.get(this.container);
+      if (handle) handle.setScale(this.scaleForViewport(this.container.clientWidth));
+      else await this.renderSlide(this.current);
+    }
   }
   searchText(query, options) {
     return searchDocument(this.presentation, query, options);
@@ -10827,11 +11011,8 @@ var NormalizedPresentationViewer = class {
     this.listCleanup = void 0;
     this.listState = void 0;
     this.clearSearchHighlights();
-    for (const url of this.objectUrls) URL.revokeObjectURL(url);
-    this.objectUrls.clear();
-    this.assetUrls.clear();
-    this.metafileUrls.clear();
-    this.pendingResources.clear();
+    this.assetCache.release();
+    this.activeMountResources = void 0;
     for (const handle of [...this.mountedHandles]) handle.dispose();
     this.handlesByTarget.clear();
     this.renderState = void 0;
@@ -10990,6 +11171,18 @@ async function parseInWorker(bytes, signal, wasmSource) {
   });
 }
 
+// src/performance.ts
+function performanceNow() {
+  return globalThis.performance?.now?.() ?? Date.now();
+}
+function performanceMeasurement(phase, startedAt, slideIndex) {
+  return {
+    durationMs: Math.max(0, performanceNow() - startedAt),
+    phase,
+    ...slideIndex === void 0 ? {} : { slideIndex }
+  };
+}
+
 // src/parse.ts
 var DEFAULT_MAX_INPUT_BYTES = 100 * 1024 * 1024;
 function isParsedPresentation(source) {
@@ -11074,14 +11267,20 @@ async function parsePresentation(source, options = {}) {
       warnings: source.warnings
     };
   }
+  const downloadStartedAt = performanceNow();
   const buffer = await readSource(source, options);
+  if (typeof source === "string" || source instanceof URL) {
+    options.onPerformanceMeasurement?.(performanceMeasurement("download", downloadStartedAt));
+  }
   const format = detectFormat(buffer, options.formatHint);
   const bytes = new Uint8Array(buffer);
   throwIfAborted(options.signal);
+  const parsingStartedAt = performanceNow();
   const nativeDocument = await parseWithWasm(bytes, {
     formatHint: format,
     ...options.signal ? { signal: options.signal } : {}
   });
+  options.onPerformanceMeasurement?.(performanceMeasurement("wasm-parsing", parsingStartedAt));
   throwIfAborted(options.signal);
   if (!nativeDocument) {
     throw new PptxViewerError(
@@ -11099,7 +11298,7 @@ var presentationParsingDefaults = Object.freeze({
   maxInputBytes: DEFAULT_MAX_INPUT_BYTES
 });
 var THUMBNAIL_ROW_ESTIMATE = 123;
-var THUMBNAIL_OVERSCAN = 3;
+var THUMBNAIL_OVERSCAN = 1;
 var THUMBNAIL_INITIAL_RECT = { height: 780, width: 184 };
 var observeThumbnailFilmstripRect = (instance, callback) => {
   const element = instance.scrollElement;
@@ -11158,7 +11357,11 @@ async function createAdapter(target, parsed, props, getCurrentProps, onCurrentSl
   const fontManager = new PptxFontManager(props.fonts, (warning) => {
     if (isCurrent()) reportWarning(warning);
   });
+  const fontStartedAt = performanceNow();
   await fontManager.prepare(parsed.document);
+  getCurrentProps().onPerformanceMeasurement?.(
+    performanceMeasurement("embedded-font-preparation", fontStartedAt)
+  );
   if (!isCurrent()) {
     fontManager.destroy();
     throw new Error("Viewer adapter creation was superseded.");
@@ -11191,6 +11394,7 @@ async function createAdapter(target, parsed, props, getCurrentProps, onCurrentSl
   const normalized = new NormalizedPresentationViewer(target, parsed.document, callbacks);
   return {
     async render(mode, slideIndex) {
+      const startedAt = performanceNow();
       if (mode === "continuous") {
         const virtualization = typeof props.virtualization === "object" ? props.virtualization : {};
         await normalized.renderList({
@@ -11204,6 +11408,9 @@ async function createAdapter(target, parsed, props, getCurrentProps, onCurrentSl
       } else {
         await normalized.renderSlide(slideIndex);
       }
+      getCurrentProps().onPerformanceMeasurement?.(
+        performanceMeasurement("slide-dom-svg-rendering", startedAt, slideIndex)
+      );
     },
     goToSlide: (index, options) => normalized.goToSlide(index, options),
     setZoom: (percent) => normalized.setZoom(percent),
@@ -11436,7 +11643,8 @@ var ReactPptxViewer = forwardRef(
         signal: abort.signal,
         ...parseFormatHint ? { formatHint: parseFormatHint } : {},
         ...parseMaxInputBytes !== void 0 ? { maxInputBytes: parseMaxInputBytes } : {},
-        ...parseFetchInit ? { fetchInit: parseFetchInit } : {}
+        ...parseFetchInit ? { fetchInit: parseFetchInit } : {},
+        onPerformanceMeasurement: (measurement) => latestPropsRef.current.onPerformanceMeasurement?.(measurement)
       }).then((next) => {
         if (abort.signal.aborted) return;
         setParsed(next);
@@ -11820,9 +12028,12 @@ function usePptxViewer() {
 }
 var EMU_PER_CSS_PIXEL2 = 9525;
 var DEFAULT_MAX_DIMENSION2 = 160;
-function normalizeSlideIndexes(indexes, slideCount) {
+function normalizeSlideIndexes(indexes, slideCount, sort = true) {
   if (!indexes?.length || slideCount <= 0) return [];
-  return [...new Set(indexes)].filter((index) => Number.isInteger(index) && index >= 0 && index < slideCount).sort((left, right) => left - right);
+  const normalized = [...new Set(indexes)].filter(
+    (index) => Number.isInteger(index) && index >= 0 && index < slideCount
+  );
+  return sort ? normalized.sort((left, right) => left - right) : normalized;
 }
 function finitePositive2(value) {
   return value !== void 0 && Number.isFinite(value) && value > 0 ? value : void 0;
@@ -11860,6 +12071,7 @@ function usePptxViewerThumbnails(controller, options = {}) {
   const attachedElementsRef = useRef(/* @__PURE__ */ new Map());
   const cleanupsRef = useRef(/* @__PURE__ */ new Map());
   const prefetchedRef = useRef(/* @__PURE__ */ new Map());
+  const prefetchInFlightRef = useRef(/* @__PURE__ */ new Map());
   const renderGenerationRef = useRef(/* @__PURE__ */ new Map());
   const refCallbacksRef = useRef(/* @__PURE__ */ new Map());
   const attachRef = useRef(() => {
@@ -11872,7 +12084,7 @@ function usePptxViewerThumbnails(controller, options = {}) {
     [options.renderWindow?.visibleSlideIndexes, slideCount]
   );
   const prefetchSlideIndexes = useMemo(
-    () => normalizeSlideIndexes(options.renderWindow?.prefetchSlideIndexes, slideCount),
+    () => normalizeSlideIndexes(options.renderWindow?.prefetchSlideIndexes, slideCount, false),
     [options.renderWindow?.prefetchSlideIndexes, slideCount]
   );
   const visibleSlideIndexesKey = visibleSlideIndexes.join(",");
@@ -11987,28 +12199,46 @@ function usePptxViewerThumbnails(controller, options = {}) {
   }, [renderThumbnail]);
   const prefetchThumbnail = useCallback(
     async (slideIndex) => {
-      if (disabled || !controller?.isReady() || attachedElementsRef.current.has(slideIndex) || prefetchedRef.current.has(slideIndex)) {
-        return;
-      }
-      const generation = (renderGenerationRef.current.get(slideIndex) ?? 0) + 1;
-      renderGenerationRef.current.set(slideIndex, generation);
-      const element = globalThis.document.createElement("div");
-      setThumbnailState(slideIndex, { status: "rendering" });
-      try {
-        const cleanup = await controller.renderThumbnail(slideIndex, element, {
-          width: size.width
-        });
-        if (!mountedRef.current || renderGenerationRef.current.get(slideIndex) !== generation || attachedElementsRef.current.has(slideIndex) || !requestedPrefetchSlideIndexSetRef.current.has(slideIndex)) {
-          cleanup();
-          return;
+      while (true) {
+        const existing = prefetchInFlightRef.current.get(slideIndex);
+        if (existing) {
+          await existing;
+          continue;
         }
-        prefetchedRef.current.set(slideIndex, { cleanup, element, width: size.width });
-        setThumbnailState(slideIndex, { status: "ready" });
-      } catch (reason) {
-        if (!mountedRef.current || renderGenerationRef.current.get(slideIndex) !== generation) {
+        if (disabled || !controller?.isReady() || attachedElementsRef.current.has(slideIndex) || prefetchedRef.current.has(slideIndex) || !requestedPrefetchSlideIndexSetRef.current.has(slideIndex)) {
           return;
         }
-        setThumbnailState(slideIndex, { error: asError(reason), status: "error" });
+        const generation = (renderGenerationRef.current.get(slideIndex) ?? 0) + 1;
+        renderGenerationRef.current.set(slideIndex, generation);
+        const element = globalThis.document.createElement("div");
+        setThumbnailState(slideIndex, { status: "rendering" });
+        const pending = (async () => {
+          try {
+            const cleanup = await controller.renderThumbnail(slideIndex, element, {
+              width: size.width
+            });
+            if (!mountedRef.current || renderGenerationRef.current.get(slideIndex) !== generation || attachedElementsRef.current.has(slideIndex) || !requestedPrefetchSlideIndexSetRef.current.has(slideIndex)) {
+              cleanup();
+              return;
+            }
+            prefetchedRef.current.set(slideIndex, { cleanup, element, width: size.width });
+            setThumbnailState(slideIndex, { status: "ready" });
+          } catch (reason) {
+            if (!mountedRef.current || renderGenerationRef.current.get(slideIndex) !== generation) {
+              return;
+            }
+            setThumbnailState(slideIndex, { error: asError(reason), status: "error" });
+          }
+        })();
+        prefetchInFlightRef.current.set(slideIndex, pending);
+        try {
+          await pending;
+        } finally {
+          if (prefetchInFlightRef.current.get(slideIndex) === pending) {
+            prefetchInFlightRef.current.delete(slideIndex);
+          }
+        }
+        return;
       }
     },
     [controller, disabled, setThumbnailState, size.width]
@@ -12024,14 +12254,17 @@ function usePptxViewerThumbnails(controller, options = {}) {
       cleanupsRef.current.clear();
       for (const prefetched of prefetchedRef.current.values()) prefetched.cleanup();
       prefetchedRef.current.clear();
+      prefetchInFlightRef.current.clear();
     };
   }, []);
   useEffect(
     () => () => {
+      for (const index of prefetchInFlightRef.current.keys()) invalidateThumbnail(index);
+      prefetchInFlightRef.current.clear();
       for (const prefetched of prefetchedRef.current.values()) prefetched.cleanup();
       prefetchedRef.current.clear();
     },
-    [controller, size.width]
+    [controller, invalidateThumbnail, size.width]
   );
   useEffect(() => {
     void rerenderAttachedThumbnails();
@@ -12043,6 +12276,13 @@ function usePptxViewerThumbnails(controller, options = {}) {
         if (!attachedElementsRef.current.has(index)) setThumbnailState(index, { status: "idle" });
       }
     }
+    for (const index of prefetchInFlightRef.current.keys()) {
+      if (disabled || attachedElementsRef.current.has(index) || !requestedPrefetchSlideIndexSetRef.current.has(index)) {
+        invalidateThumbnail(index);
+        prefetchInFlightRef.current.delete(index);
+        if (!attachedElementsRef.current.has(index)) setThumbnailState(index, { status: "idle" });
+      }
+    }
     if (disabled) return;
     let cancelled = false;
     void (async () => {
@@ -12057,6 +12297,7 @@ function usePptxViewerThumbnails(controller, options = {}) {
   }, [
     disabled,
     disposePrefetchedThumbnail,
+    invalidateThumbnail,
     prefetchSlideIndexesKey,
     prefetchThumbnail,
     setThumbnailState
@@ -12096,6 +12337,404 @@ function usePptxViewerThumbnails(controller, options = {}) {
   );
 }
 
-export { OFFICE_FONT_FALLBACKS, PptxViewerError, ReactPptxViewer, initWasm, parsePresentation, presentationParsingDefaults, resolvePptxFontFamily, setWasmSource, usePptxModel, usePptxPresentation, usePptxViewer, usePptxViewerThumbnails };
+// src/thumbnail-renderer.ts
+var EMU_PER_CSS_PIXEL3 = 9525;
+var DEFAULT_MAX_DIMENSION3 = 160;
+var RenderQueue = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  active = 0;
+  destroyed = false;
+  waiters = [];
+  acquire(signal) {
+    throwIfAborted(signal);
+    if (this.destroyed) return Promise.reject(abortedError());
+    return new Promise((resolve, reject) => {
+      const waiter = { resolve, reject, ...signal ? { signal } : {} };
+      if (signal) {
+        waiter.abort = () => {
+          const index = this.waiters.indexOf(waiter);
+          if (index >= 0) this.waiters.splice(index, 1);
+          reject(abortedError(signal.reason));
+        };
+        signal.addEventListener("abort", waiter.abort, { once: true });
+      }
+      this.waiters.push(waiter);
+      this.drain();
+    });
+  }
+  destroy() {
+    this.destroyed = true;
+    for (const waiter of this.waiters.splice(0)) {
+      if (waiter.abort && waiter.signal) {
+        waiter.signal.removeEventListener("abort", waiter.abort);
+      }
+      waiter.reject(abortedError());
+    }
+  }
+  drain() {
+    while (!this.destroyed && this.active < this.limit && this.waiters.length) {
+      const waiter = this.waiters.shift();
+      if (waiter.abort && waiter.signal) {
+        waiter.signal.removeEventListener("abort", waiter.abort);
+      }
+      if (waiter.signal?.aborted) {
+        waiter.reject(abortedError(waiter.signal.reason));
+        continue;
+      }
+      this.active += 1;
+      let released = false;
+      waiter.resolve(() => {
+        if (released) return;
+        released = true;
+        this.active -= 1;
+        this.drain();
+      });
+    }
+  }
+};
+function abortedError(reason) {
+  return new PptxViewerError("aborted", "Thumbnail rendering was cancelled.", { cause: reason });
+}
+function finitePositive3(value, fallback) {
+  return value !== void 0 && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function outputSize(presentation, options) {
+  const naturalWidth = Math.max(1, presentation.document.size.widthEmu / EMU_PER_CSS_PIXEL3);
+  const naturalHeight = Math.max(1, presentation.document.size.heightEmu / EMU_PER_CSS_PIXEL3);
+  const hasWidth = options.maxWidth !== void 0 && Number.isFinite(options.maxWidth) && options.maxWidth > 0;
+  const hasHeight = options.maxHeight !== void 0 && Number.isFinite(options.maxHeight) && options.maxHeight > 0;
+  const maxWidth = hasWidth ? options.maxWidth : hasHeight ? Number.POSITIVE_INFINITY : DEFAULT_MAX_DIMENSION3;
+  const maxHeight = hasHeight ? options.maxHeight : hasWidth ? Number.POSITIVE_INFINITY : DEFAULT_MAX_DIMENSION3;
+  const scale = Math.min(maxWidth / naturalWidth, maxHeight / naturalHeight);
+  return {
+    height: Math.max(1, Math.round(naturalHeight * scale)),
+    naturalHeight,
+    naturalWidth,
+    width: Math.max(1, Math.round(naturalWidth * scale))
+  };
+}
+function blobToDataUrl(blob, signal) {
+  return abortable(
+    new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(String(reader.result));
+      reader.onerror = () => reject(reader.error ?? new Error("Could not read a slide asset."));
+      reader.readAsDataURL(blob);
+    }),
+    signal
+  );
+}
+async function inlineResourceUrl(url, signal) {
+  if (!/^(?:blob:|https?:)/i.test(url)) return url;
+  try {
+    const response = await fetch(url, signal ? { signal } : void 0);
+    if (!response.ok) return url;
+    return await blobToDataUrl(await response.blob(), signal);
+  } catch {
+    throwIfAborted(signal);
+    return url;
+  }
+}
+async function inlineResources(root, signal) {
+  const cache = /* @__PURE__ */ new Map();
+  const inline = (url) => {
+    let pending = cache.get(url);
+    if (!pending) {
+      pending = inlineResourceUrl(url, signal);
+      cache.set(url, pending);
+    }
+    return pending;
+  };
+  const elements = [root, ...root.querySelectorAll("*")];
+  await Promise.all(
+    elements.flatMap((element) => {
+      const attributeNames = ["src", "poster", ...element.localName === "image" ? ["href"] : []];
+      const attributes = attributeNames.map((name) => ({ name, value: element.getAttribute(name) })).filter((entry) => Boolean(entry.value));
+      const attributeTasks = attributes.map(async ({ name, value }) => {
+        element.setAttribute(name, await inline(value));
+      });
+      const styleTasks = Array.from(
+        { length: element.style.length },
+        (_, index) => element.style.item(index)
+      ).map((property) => ({ property, value: element.style.getPropertyValue(property) })).filter(({ value }) => value.includes("url(")).map(async ({ property, value }) => {
+        const urls = [...value.matchAll(/url\(["']?([^"')]+)["']?\)/g)].map((match) => match[1]);
+        let next = value;
+        for (const url of urls) next = next.replace(url, await inline(url));
+        element.style.setProperty(property, next);
+      });
+      return [...attributeTasks, ...styleTasks];
+    })
+  );
+}
+async function serializeSlide(slide, naturalWidth, naturalHeight, width, height, signal) {
+  const clone = slide.cloneNode(true);
+  clone.style.transform = "none";
+  clone.style.transformOrigin = "top left";
+  clone.setAttribute("xmlns", "http://www.w3.org/1999/xhtml");
+  const sourceCanvases = slide.querySelectorAll("canvas");
+  const clonedCanvases = clone.querySelectorAll("canvas");
+  sourceCanvases.forEach((canvas, index) => {
+    const cloned = clonedCanvases[index];
+    if (!cloned) return;
+    try {
+      const image = document.createElement("img");
+      image.src = canvas.toDataURL("image/png");
+      image.setAttribute("style", cloned.getAttribute("style") ?? "");
+      cloned.replaceWith(image);
+    } catch {
+      cloned.remove();
+    }
+  });
+  await inlineResources(clone, signal);
+  const content = new XMLSerializer().serializeToString(clone);
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${naturalWidth} ${naturalHeight}"><foreignObject width="${naturalWidth}" height="${naturalHeight}">${content}</foreignObject></svg>`;
+}
+async function abortable(promise, signal) {
+  throwIfAborted(signal);
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(abortedError(signal.reason));
+    signal.addEventListener("abort", abort, { once: true });
+    void promise.then(
+      (value) => {
+        signal.removeEventListener("abort", abort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      }
+    );
+  });
+}
+async function decodeElementImages(root, signal) {
+  const images = [...root.querySelectorAll("img")];
+  const svgImages = [...root.querySelectorAll("image")].map((image) => image.href.baseVal || image.getAttribute("href") || "").filter(Boolean);
+  await abortable(
+    Promise.all([
+      ...images.map(async (image) => {
+        if (typeof image.decode === "function") await image.decode().catch(() => void 0);
+      }),
+      ...svgImages.map(
+        (source) => new Promise((resolve) => {
+          const image = new Image();
+          image.onload = () => resolve();
+          image.onerror = () => resolve();
+          image.src = source;
+        })
+      )
+    ]).then(() => void 0),
+    signal
+  );
+}
+async function decodeSvg(svg, signal) {
+  return abortable(
+    new Promise((resolve, reject) => {
+      const image = new Image();
+      image.onload = () => resolve(image);
+      image.onerror = () => reject(new Error("The rendered slide SVG could not be decoded."));
+      image.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+    }),
+    signal
+  );
+}
+function canvasToBlob(canvas, quality) {
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (blob) => {
+        if (blob) resolve(blob);
+        else reject(new Error("The browser could not encode the thumbnail."));
+      },
+      "image/png",
+      quality
+    );
+  });
+}
+var ThumbnailRenderer = class {
+  constructor(presentation, options) {
+    this.presentation = presentation;
+    this.options = options;
+    if (typeof document === "undefined") {
+      throw new PptxViewerError(
+        "unsupported-environment",
+        "Thumbnail rendering requires a browser DOM."
+      );
+    }
+    const concurrency = Math.max(1, Math.floor(finitePositive3(options.concurrency, 2)));
+    this.queue = new RenderQueue(concurrency);
+    this.root = document.createElement("div");
+    this.root.setAttribute("aria-hidden", "true");
+    this.root.style.position = "fixed";
+    this.root.style.left = "-100000px";
+    this.root.style.top = "0";
+    this.root.style.pointerEvents = "none";
+    this.root.style.opacity = "0";
+    document.body.append(this.root);
+    this.fontManager = new PptxFontManager(
+      {
+        loadEmbeddedFonts: false,
+        reportMissingFonts: false,
+        waitForFonts: false,
+        ...options.fonts
+      },
+      (warning) => options.onWarning?.(warning)
+    );
+    this.viewer = new NormalizedPresentationViewer(this.root, presentation.document, {
+      onNodeError: (nodeId, error) => options.onWarning?.({
+        code: "degraded-rendering",
+        severity: "warning",
+        nodeId,
+        feature: "thumbnail-renderer",
+        message: `A slide element could not be rendered: ${error instanceof Error ? error.message : String(error)}`
+      })
+    });
+    const startedAt = performanceNow();
+    this.ready = this.fontManager.prepare(presentation.document).then(() => {
+      this.report(performanceMeasurement("embedded-font-preparation", startedAt));
+    });
+  }
+  presentation;
+  options;
+  ready;
+  fontManager;
+  queue;
+  root;
+  viewer;
+  destroyed = false;
+  async renderSlide(slideIndex, options = {}) {
+    const release = await this.queue.acquire(options.signal);
+    try {
+      this.assertAvailable(options.signal);
+      await abortable(this.ready, options.signal);
+      this.assertAvailable(options.signal);
+      if (!Number.isInteger(slideIndex) || slideIndex < 0 || slideIndex >= this.presentation.document.slides.length) {
+        throw new RangeError(`Slide ${slideIndex} does not exist.`);
+      }
+      const measurements = [];
+      const size = outputSize(this.presentation, options);
+      const target = document.createElement("div");
+      this.root.append(target);
+      const domStartedAt = performanceNow();
+      const handle = this.viewer.renderThumbnailToContainer(slideIndex, target, {
+        width: size.naturalWidth
+      });
+      try {
+        await abortable(handle.ready, options.signal);
+        this.fontManager.applyTo(handle.element, slideIndex);
+        const domDurationMs = performanceNow() - domStartedAt;
+        const decodeStartedAt = performanceNow();
+        await decodeElementImages(handle.element, options.signal);
+        let decodeDurationMs = performanceNow() - decodeStartedAt;
+        const serializationStartedAt = performanceNow();
+        const svg = await serializeSlide(
+          handle.element,
+          size.naturalWidth,
+          size.naturalHeight,
+          size.width,
+          size.height,
+          options.signal
+        );
+        this.record(
+          {
+            durationMs: Math.max(0, domDurationMs + performanceNow() - serializationStartedAt),
+            phase: "slide-dom-svg-rendering",
+            slideIndex
+          },
+          measurements
+        );
+        const output = options.output ?? "blob";
+        if (output === "svg") {
+          this.record(
+            { durationMs: Math.max(0, decodeDurationMs), phase: "image-decoding", slideIndex },
+            measurements
+          );
+          return this.result(svg, output, slideIndex, size, measurements);
+        }
+        const svgDecodeStartedAt = performanceNow();
+        const image = await decodeSvg(svg, options.signal);
+        decodeDurationMs += performanceNow() - svgDecodeStartedAt;
+        this.record(
+          { durationMs: Math.max(0, decodeDurationMs), phase: "image-decoding", slideIndex },
+          measurements
+        );
+        this.assertAvailable(options.signal);
+        const encodeStartedAt = performanceNow();
+        const pixelRatio = finitePositive3(options.pixelRatio, 1);
+        const canvas = document.createElement("canvas");
+        canvas.width = Math.max(1, Math.round(size.width * pixelRatio));
+        canvas.height = Math.max(1, Math.round(size.height * pixelRatio));
+        canvas.style.width = `${size.width}px`;
+        canvas.style.height = `${size.height}px`;
+        const context = canvas.getContext("2d");
+        if (!context) throw new Error("The browser does not provide a 2D canvas renderer.");
+        context.drawImage(image, 0, 0, canvas.width, canvas.height);
+        let data;
+        if (output === "canvas") data = canvas;
+        else if (output === "imageBitmap") {
+          if (typeof createImageBitmap !== "function") {
+            throw new PptxViewerError(
+              "unsupported-environment",
+              "ImageBitmap output is not supported by this browser."
+            );
+          }
+          data = await abortable(createImageBitmap(canvas), options.signal);
+        } else data = await abortable(canvasToBlob(canvas, options.quality), options.signal);
+        this.measure("raster-encoding", encodeStartedAt, slideIndex, measurements);
+        return this.result(data, output, slideIndex, size, measurements);
+      } finally {
+        handle.dispose();
+        target.remove();
+      }
+    } finally {
+      release();
+    }
+  }
+  renderSlides(slideIndexes, options = {}) {
+    return Promise.all(slideIndexes.map((slideIndex) => this.renderDynamic(slideIndex, options)));
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.queue.destroy();
+    this.viewer.destroy();
+    this.fontManager.destroy();
+    this.root.remove();
+  }
+  renderDynamic(slideIndex, options) {
+    return this.renderSlide(slideIndex, options);
+  }
+  assertAvailable(signal) {
+    throwIfAborted(signal);
+    if (this.destroyed) throw abortedError();
+  }
+  measure(phase, startedAt, slideIndex, measurements) {
+    this.record(performanceMeasurement(phase, startedAt, slideIndex), measurements);
+  }
+  record(measurement, measurements) {
+    measurements.push(measurement);
+    this.report(measurement);
+  }
+  report(measurement) {
+    this.options.onPerformanceMeasurement?.(measurement);
+  }
+  result(data, output, slideIndex, size, measurements) {
+    return {
+      data,
+      height: size.height,
+      measurements,
+      output,
+      slideIndex,
+      width: size.width
+    };
+  }
+};
+function createPptxThumbnailRenderer(presentation, options = {}) {
+  return new ThumbnailRenderer(presentation, options);
+}
+
+export { OFFICE_FONT_FALLBACKS, PptxViewerError, ReactPptxViewer, createPptxThumbnailRenderer, initWasm, parsePresentation, presentationParsingDefaults, resolvePptxFontFamily, setWasmSource, usePptxModel, usePptxPresentation, usePptxViewer, usePptxViewerThumbnails };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map