@extend-ai/react-pptx 0.1.2 → 0.2.0

package/dist/index.js

@@ -9247,6 +9247,64 @@ 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) {
@@ -9788,6 +9846,7 @@ var NormalizedPresentationViewer = class {
     this.container = container;
     this.presentation = presentation;
     this.callbacks = callbacks;
+    this.assetCache = acquirePresentationAssetCache(presentation);
   }
   container;
   presentation;
@@ -9795,9 +9854,7 @@ var NormalizedPresentationViewer = class {
   current = 0;
   zoom = 100;
   fit = "contain";
-  objectUrls = /* @__PURE__ */ new Set();
-  assetUrls = /* @__PURE__ */ new Map();
-  metafileUrls = /* @__PURE__ */ new Map();
+  assetCache;
   listCleanup;
   highlight;
   activeMountResources;
@@ -9853,36 +9910,8 @@ 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];
@@ -10982,10 +11011,7 @@ 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.assetCache.release();
     this.activeMountResources = void 0;
     for (const handle of [...this.mountedHandles]) handle.dispose();
     this.handlesByTarget.clear();
@@ -11145,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) {
@@ -11229,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(
@@ -11313,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.");
@@ -11346,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({
@@ -11359,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),
@@ -11591,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);
@@ -12284,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