From 8fac18e2e15bfe6b196394bc726008309ebc64f6 Mon Sep 17 00:00:00 2001
From: TomasPalsson <tomas2212042710@gmail.com>
Date: Fri, 2 Oct 2026 13:34:46 +0000
Subject: [PATCH] =?UTF-8?q?=F0=9F=96=BC=EF=B8=8F=20fix:=20Show=20EMF/WMF?=
 =?UTF-8?q?=20Pictures=20in=20PowerPoint=20Previews?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

pptx-preview turns EMF/WMF media into data:image/x-emf URIs, which no
browser can decode, so template logos stored as metafiles render as
broken images. Convert them to SVG on the server with emf-converter
(pinned 4.8.7, Apache-2.0, no deps), embed the SVGs keyed by a hash of
the media's base64, and swap them into the rendered <img> elements once
the slides are drawn.

Bounded by count, per-file, total-input, output and time budgets; a
deck whose preview fits today never loses it to the added map.
---
 api/package.json                              |   1 +
 package-lock.json                             |  30 ++++
 packages/api/package.json                     |   1 +
 packages/api/src/files/documents/html.spec.ts |  88 ++++++++++++
 packages/api/src/files/documents/html.ts      |  38 ++++-
 .../api/src/files/documents/metafiles.spec.ts | 106 ++++++++++++++
 packages/api/src/files/documents/metafiles.ts | 132 ++++++++++++++++++
 7 files changed, 394 insertions(+), 2 deletions(-)
 create mode 100644 packages/api/src/files/documents/metafiles.spec.ts
 create mode 100644 packages/api/src/files/documents/metafiles.ts

diff --git a/api/package.json b/api/package.json
index 3d672cba2e7..e58f2df9f5a 100644
--- a/api/package.json
+++ b/api/package.json
@@ -76,6 +76,7 @@
     "dedent": "^1.5.3",
     "dompurify": "^3.4.12",
     "dotenv": "^16.0.3",
+    "emf-converter": "4.8.7",
     "eventsource": "^3.0.2",
     "express": "^5.2.1",
     "express-mongo-sanitize": "^2.2.0",
diff --git a/package-lock.json b/package-lock.json
index 190c93550c2..1f751841261 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -94,6 +94,7 @@
         "dedent": "^1.5.3",
         "dompurify": "^3.4.12",
         "dotenv": "^16.0.3",
+        "emf-converter": "4.8.7",
         "eventsource": "^3.0.2",
         "express": "^5.2.1",
         "express-mongo-sanitize": "^2.2.0",
@@ -760,6 +761,20 @@
         "node": ">= 0.8.0"
       }
     },
+    "api/node_modules/emf-converter": {
+      "version": "4.8.7",
+      "resolved": "https://registry.npmjs.org/emf-converter/-/emf-converter-4.8.7.tgz",
+      "integrity": "sha512-oxnd2LVALXdVsIDlwInIH+kSYBB4+qSJsg0pPF5JqArSnH7G/FdbMwbdL4lHlYIWsX+VAOdt1bYlXLyZcuAqRw==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@napi-rs/canvas": "^1.0.9"
+      },
+      "peerDependenciesMeta": {
+        "@napi-rs/canvas": {
+          "optional": true
+        }
+      }
+    },
     "api/node_modules/file-type": {
       "version": "21.3.2",
       "resolved": "https://registry.npmjs.org/file-type/-/file-type-21.3.2.tgz",
@@ -42391,6 +42406,7 @@
         "@langchain/langgraph-checkpoint-mongodb": "^1.4.0",
         "cluster-key-slot": "^1.1.2",
         "croner": "^10.0.1",
+        "emf-converter": "4.8.7",
         "express-rate-limit": "^8.5.1",
         "helmet": "^8.3.0",
         "proxy-from-env": "^2.1.0",
@@ -42878,6 +42894,20 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
+    "packages/api/node_modules/emf-converter": {
+      "version": "4.8.7",
+      "resolved": "https://registry.npmjs.org/emf-converter/-/emf-converter-4.8.7.tgz",
+      "integrity": "sha512-oxnd2LVALXdVsIDlwInIH+kSYBB4+qSJsg0pPF5JqArSnH7G/FdbMwbdL4lHlYIWsX+VAOdt1bYlXLyZcuAqRw==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@napi-rs/canvas": "^1.0.9"
+      },
+      "peerDependenciesMeta": {
+        "@napi-rs/canvas": {
+          "optional": true
+        }
+      }
+    },
     "packages/api/node_modules/get-tsconfig": {
       "version": "5.0.0-beta.5",
       "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-5.0.0-beta.5.tgz",
diff --git a/packages/api/package.json b/packages/api/package.json
index 7c12e936328..e057bc20bcf 100644
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -181,6 +181,7 @@
     "@langchain/langgraph-checkpoint-mongodb": "^1.4.0",
     "cluster-key-slot": "^1.1.2",
     "croner": "^10.0.1",
+    "emf-converter": "4.8.7",
     "express-rate-limit": "^8.5.1",
     "helmet": "^8.3.0",
     "proxy-from-env": "^2.1.0",
diff --git a/packages/api/src/files/documents/html.spec.ts b/packages/api/src/files/documents/html.spec.ts
index a46a6682788..a9915aa28ee 100644
--- a/packages/api/src/files/documents/html.spec.ts
+++ b/packages/api/src/files/documents/html.spec.ts
@@ -21,6 +21,51 @@ import {
   wordDocToHtml,
 } from './html';
 import { ZipBombError } from './zipSafety';
+import * as metafiles from './metafiles';
+
+/** Minimal valid little-endian EMF: header, brush, select, rectangle, EOF. */
+function buildEmf(): Buffer {
+  const parts: Buffer[] = [];
+  const rec = (type: number, size: number, ...ints: number[]): Buffer => {
+    const b = Buffer.alloc(size);
+    b.writeUInt32LE(type, 0);
+    b.writeUInt32LE(size, 4);
+    ints.forEach((v, i) => b.writeInt32LE(v | 0, 8 + i * 4));
+    return b;
+  };
+  const header = rec(
+    1,
+    108,
+    0,
+    0,
+    99,
+    49, // bounds
+    0,
+    0,
+    2645,
+    1322, // frame
+    0x464d4520, // signature
+    0x10000, // version
+    0, // bytes (patched below)
+    5, // records
+    2, // handles (u32 + reserved u16 packed)
+    0, // nDescription
+    0, // offDescription
+    0, // nPalEntries
+    1920,
+    1080, // device
+    508,
+    286, // millimeters
+  );
+  parts.push(header);
+  parts.push(rec(39, 24, 1, 0, 0x00ff0000, 0));
+  parts.push(rec(37, 12, 1));
+  parts.push(rec(43, 24, 0, 0, 99, 49));
+  parts.push(rec(14, 20, 0, 16, 20));
+  const out = Buffer.concat(parts);
+  out.writeUInt32LE(out.length, 48);
+  return out;
+}
 
 const fixturesDir = __dirname;
 const readFixture = (name: string): Buffer => fs.readFileSync(path.join(fixturesDir, name));
@@ -419,6 +464,49 @@ describe('Office HTML producers', () => {
       return zip.generateAsync({ type: 'nodebuffer' });
     };
 
+    describe('EMF/WMF metafile swap', () => {
+      const withEmf = async (): Promise<Buffer> => {
+        const zip = await JSZip.loadAsync(await buildPptx([{ title: 'T' }]));
+        zip.file('ppt/media/image1.emf', buildEmf());
+        return zip.generateAsync({ type: 'nodebuffer' });
+      };
+
+      afterEach(() => jest.restoreAllMocks());
+
+      test('embeds converted SVGs for pptx metafiles', async () => {
+        const html = await pptxToHtml(await withEmf());
+        expect(html).toContain('id="lc-metafiles"');
+        expect(html).toContain(metafiles.metafileKey(buildEmf().toString('base64')));
+        expect(html).toContain('swapMetafiles');
+      });
+
+      test('escapes < in the JSON block so </script> cannot break out', async () => {
+        const html = await _internal.pptxToHtmlViaCdn(
+          await buildPptx([{ title: 'X' }]),
+          '',
+          false,
+          { k: 'data:x</script><b>' },
+        );
+        const block = html.split('id="lc-metafiles"')[1].split('</script>')[0];
+        expect(block).toContain('\\u003c/script>');
+        expect(block).not.toContain('</script>');
+        expect(html).toContain('\\u003c/script>');
+      });
+
+      test('omits the block when there are no metafiles', async () => {
+        const html = await pptxToHtml(await buildPptx([{ title: 'T' }]));
+        expect(html).not.toContain('id="lc-metafiles"');
+      });
+
+      test('drops the map, keeping the CDN doc, when it would exceed the output cap', async () => {
+        const huge = { k: 'a'.repeat(_internal.OFFICE_HTML_OUTPUT_CAP) };
+        jest.spyOn(metafiles, 'extractPptxMetafileSvgs').mockResolvedValue(huge);
+        const html = await pptxToHtml(await buildPptx([{ title: 'T' }]));
+        expect(html).toContain('cdn.jsdelivr.net/npm/pptx-preview@');
+        expect(html).not.toContain('id="lc-metafiles"');
+      });
+    });
+
     test('routes a small pptx (≤ cap) through the CDN-rendered path', async () => {
       const pptx = await buildPptx([{ title: 'Hello', body: ['First slide'] }]);
       const html = await pptxToHtml(pptx);
diff --git a/packages/api/src/files/documents/html.ts b/packages/api/src/files/documents/html.ts
index ff23d957065..b0009e6e435 100644
--- a/packages/api/src/files/documents/html.ts
+++ b/packages/api/src/files/documents/html.ts
@@ -6,6 +6,7 @@ import {
   OFFICE_FILE_SHELL_MARKER,
 } from 'librechat-data-provider';
 import { tryLibreOfficePreview } from './libreoffice';
+import { METAFILE_KEY_JS, extractPptxMetafileSvgs } from './metafiles';
 import { assertSafeZipSize } from './zipSafety';
 
 /**
@@ -1115,7 +1116,14 @@ function buildPptxCdnDocument(
   base64: string,
   slideListFallbackBody: string,
   fileShell = false,
+  metafileSvgs: Record<string, string> = {},
 ): string {
+  /* Server-converted EMF/WMF → SVG map. `<` is escaped so a value can
+   * never close the script element. */
+  const metafileBlock =
+    Object.keys(metafileSvgs).length > 0
+      ? `<script id="lc-metafiles" type="application/json">${JSON.stringify(metafileSvgs).replace(/</g, '\\u003c')}</script>\n`
+      : '';
   /* PPTX-specific CSP relaxations vs DOCX:
    *   - `worker-src blob:` — pptx-preview's bundled echarts dep spins up
    *     Web Workers via blob: URLs for chart rendering. Without this,
@@ -1229,9 +1237,10 @@ ${PPTX_SLIDE_LIST_CSS}
   </details>
 </div>
 ${fileShell ? OFFICE_DOC_DATA_SLOT : `<script id="lc-doc-data" type="application/octet-stream;base64">${base64}</script>`}
-<script>
+${metafileBlock}<script>
 (function () {
   var settled = false;
+  var metafileKey = ${METAFILE_KEY_JS};
   function showFallback(reason) {
     if (settled) { return; }
     settled = true;
@@ -1428,6 +1437,16 @@ ${fileShell ? OFFICE_DOC_DATA_SLOT : `<script id="lc-doc-data" type="application
       return false;
     }
 
+    function swapMetafiles() {
+      try {
+        var m = JSON.parse(document.getElementById('lc-metafiles').textContent);
+        container.querySelectorAll('img[src^="data:image/x-emf;"],img[src^="data:image/x-wmf;"]').forEach(function (i) {
+          var u = m[metafileKey(i.getAttribute('src').split(',')[1])];
+          if (u) { i.src = u; }
+        });
+      } catch (e) {}
+    }
+
     function finalize() {
       /* previewer.preview() and the safety-net timer both call this; the
        * timer already guards on settled before calling it, but the
@@ -1435,6 +1454,7 @@ ${fileShell ? OFFICE_DOC_DATA_SLOT : `<script id="lc-doc-data" type="application
        * instead of at each call site. */
       if (settled) { return; }
       wrapSlides();
+      swapMetafiles();
       if (!hasRenderedContent()) {
         showFallback('renderer-empty-slide-list');
         return;
@@ -1499,11 +1519,13 @@ async function pptxToHtmlViaCdn(
   buffer: Buffer,
   slideListFallbackBody: string,
   fileShell = false,
+  metafileSvgs: Record<string, string> = {},
 ): Promise<string> {
   return buildPptxCdnDocument(
     fileShell ? '' : buffer.toString('base64'),
     slideListFallbackBody,
     fileShell,
+    metafileSvgs,
   );
 }
 
@@ -1550,8 +1572,13 @@ export async function pptxToHtml(
    * the empty-render case and reveals this slide-list fallback so the
    * user always gets readable content. Manual e2e on PR #12934. */
   const slideListBody = await renderPptxSlidesBodyForBuffer(buffer);
-  const cdnDoc = await pptxToHtmlViaCdn(buffer, slideListBody, fileShell);
+  const metafileSvgs = await extractPptxMetafileSvgs(buffer);
+  const cdnDoc = await pptxToHtmlViaCdn(buffer, slideListBody, fileShell, metafileSvgs);
   if (fileShell && Buffer.byteLength(cdnDoc, 'utf-8') > OFFICE_HTML_OUTPUT_CAP) {
+    const shellDoc = await pptxToHtmlViaCdn(buffer, '', true, metafileSvgs);
+    if (Buffer.byteLength(shellDoc, 'utf-8') <= OFFICE_HTML_OUTPUT_CAP) {
+      return shellDoc;
+    }
     return pptxToHtmlViaCdn(buffer, '', true);
   }
   /* Combined size budget: if base64 binary + slide-list fallback +
@@ -1559,6 +1586,13 @@ export async function pptxToHtml(
    * the slide-list standalone. Same pattern as the DOCX dispatcher's
    * size budget. */
   if (Buffer.byteLength(cdnDoc, 'utf-8') > OFFICE_HTML_OUTPUT_CAP) {
+    const plainDoc = await pptxToHtmlViaCdn(buffer, slideListBody, false);
+    if (
+      Object.keys(metafileSvgs).length > 0 &&
+      Buffer.byteLength(plainDoc, 'utf-8') <= OFFICE_HTML_OUTPUT_CAP
+    ) {
+      return plainDoc;
+    }
     return pptxToSlideListHtmlInternal(buffer);
   }
   return cdnDoc;
diff --git a/packages/api/src/files/documents/metafiles.spec.ts b/packages/api/src/files/documents/metafiles.spec.ts
new file mode 100644
index 00000000000..fe8ff76bfdf
--- /dev/null
+++ b/packages/api/src/files/documents/metafiles.spec.ts
@@ -0,0 +1,106 @@
+import JSZip from 'jszip';
+import { convertMetafileToSvg } from 'emf-converter';
+import { extractPptxMetafileSvgs, metafileKey, METAFILE_KEY_JS } from './metafiles';
+
+/** Minimal valid little-endian EMF: header, brush, select, rectangle, EOF. */
+function buildEmf(): Buffer {
+  const parts: Buffer[] = [];
+  const rec = (type: number, size: number, ...ints: number[]): Buffer => {
+    const b = Buffer.alloc(size);
+    b.writeUInt32LE(type, 0);
+    b.writeUInt32LE(size, 4);
+    ints.forEach((v, i) => b.writeInt32LE(v | 0, 8 + i * 4));
+    return b;
+  };
+  const header = rec(
+    1,
+    108,
+    0,
+    0,
+    99,
+    49, // bounds
+    0,
+    0,
+    2645,
+    1322, // frame
+    0x464d4520, // signature
+    0x10000, // version
+    0, // bytes (patched below)
+    5, // records
+    2, // handles (u32 + reserved u16 packed)
+    0, // nDescription
+    0, // offDescription
+    0, // nPalEntries
+    1920,
+    1080, // device
+    508,
+    286, // millimeters
+  );
+  parts.push(header);
+  parts.push(rec(39, 24, 1, 0, 0x00ff0000, 0));
+  parts.push(rec(37, 12, 1));
+  parts.push(rec(43, 24, 0, 0, 99, 49));
+  parts.push(rec(14, 20, 0, 16, 20));
+  const out = Buffer.concat(parts);
+  out.writeUInt32LE(out.length, 48);
+  return out;
+}
+
+const buildZip = async (files: Record<string, Buffer | string>): Promise<Buffer> => {
+  const zip = new JSZip();
+  for (const [name, data] of Object.entries(files)) {
+    zip.file(name, data);
+  }
+  return zip.generateAsync({ type: 'nodebuffer' });
+};
+
+describe('metafiles', () => {
+  const emf = buildEmf();
+
+  test('fixture converts with emf-converter', async () => {
+    const ab = emf.buffer.slice(emf.byteOffset, emf.byteOffset + emf.byteLength);
+    const svg = await convertMetafileToSvg(ab as ArrayBuffer, { idPrefix: 'x-' });
+    expect(svg).toContain('<svg');
+  });
+
+  test('extracts only convertible emf/wmf entries, keyed by base64 hash', async () => {
+    const pptx = await buildZip({
+      'ppt/media/image1.emf': emf,
+      'ppt/media/image2.png': Buffer.from([1, 2, 3]),
+      'ppt/media/logo.emf': emf,
+      'ppt/media/image3.emf': Buffer.from('garbage bytes that are not an emf'),
+    });
+    const map = await extractPptxMetafileSvgs(pptx);
+    expect(Object.keys(map)).toEqual([metafileKey(emf.toString('base64'))]);
+    const value = Object.values(map)[0];
+    expect(value.startsWith('data:image/svg+xml;base64,')).toBe(true);
+    expect(
+      Buffer.from(value.slice('data:image/svg+xml;base64,'.length), 'base64').toString(),
+    ).toContain('<svg');
+  });
+
+  test('resolves {} for a non-zip buffer', async () => {
+    await expect(extractPptxMetafileSvgs(Buffer.from('not a zip'))).resolves.toEqual({});
+  });
+
+  test('stops converting once the time budget is spent', async () => {
+    const blue = Buffer.from(emf);
+    blue.writeInt32LE(0x000000ff, 108 + 16);
+    const pptx = await buildZip({ 'ppt/media/image1.emf': emf, 'ppt/media/image2.emf': blue });
+    const now = jest.spyOn(Date, 'now');
+    now.mockReturnValueOnce(0).mockReturnValueOnce(0).mockReturnValue(10_000);
+    try {
+      const map = await extractPptxMetafileSvgs(pptx);
+      expect(Object.keys(map)).toEqual([metafileKey(emf.toString('base64'))]);
+    } finally {
+      now.mockRestore();
+    }
+  });
+
+  test('METAFILE_KEY_JS matches metafileKey', () => {
+    const fn = new Function('return (' + METAFILE_KEY_JS + ')')() as (s: string) => string;
+    for (const s of ['', 'abc', Buffer.alloc(52500, 7).toString('base64')]) {
+      expect(fn(s)).toBe(metafileKey(s));
+    }
+  });
+});
diff --git a/packages/api/src/files/documents/metafiles.ts b/packages/api/src/files/documents/metafiles.ts
new file mode 100644
index 00000000000..4aaf7bed4f5
--- /dev/null
+++ b/packages/api/src/files/documents/metafiles.ts
@@ -0,0 +1,132 @@
+import yauzl from 'yauzl';
+import { logger } from '@librechat/data-schemas';
+import { convertMetafileToSvg } from 'emf-converter';
+import { megabyte } from 'librechat-data-provider';
+
+/* Browsers cannot decode EMF/WMF, so pptx-preview's `<img>` for them is
+ * broken. We convert on the server and let the iframe swap them in. */
+const METAFILE_NAME = /^ppt\/media\/image[^/]*\.(emf|wmf)$/i;
+const MAX_METAFILES = 64;
+const MAX_METAFILE_BYTES = 5 * megabyte;
+const MAX_SVG_BYTES = 256 * 1024;
+const MAX_TOTAL_SVG_BYTES = 384 * 1024;
+/* Conversion is synchronous CPU work on the event loop; these bound a hostile
+ * deck. Checked between entries, so one entry may overrun the time budget. */
+const MAX_TOTAL_METAFILE_BYTES = 8 * megabyte;
+const MAX_CONVERT_MS = 3000;
+
+/** FNV-1a 32-bit over UTF-16 code units; must match `METAFILE_KEY_JS`. */
+export function metafileKey(base64: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < base64.length; i++) {
+    h ^= base64.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16) + ':' + base64.length;
+}
+
+/** Same algorithm as `metafileKey`, as ES5 source for the iframe bootstrap. */
+export const METAFILE_KEY_JS =
+  'function(s){var h=0x811c9dc5;for(var i=0;i<s.length;i++){h^=s.charCodeAt(i);h=Math.imul(h,0x01000193)>>>0}return h.toString(16)+":"+s.length}';
+
+function readEntryBuffer(zipfile: yauzl.ZipFile, entry: yauzl.Entry): Promise<Buffer | null> {
+  return new Promise((resolve) => {
+    zipfile.openReadStream(entry, (err, stream) => {
+      if (err || !stream) {
+        return resolve(null);
+      }
+      const chunks: Buffer[] = [];
+      let total = 0;
+      stream.on('data', (chunk: Buffer) => {
+        total += chunk.byteLength;
+        if (total > MAX_METAFILE_BYTES) {
+          stream.destroy();
+          return resolve(null);
+        }
+        chunks.push(chunk);
+      });
+      stream.on('end', () => resolve(Buffer.concat(chunks)));
+      stream.on('error', () => resolve(null));
+    });
+  });
+}
+
+async function convertToDataUri(bytes: Buffer, index: number): Promise<string | null> {
+  try {
+    const ab = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    const svg = await convertMetafileToSvg(ab as ArrayBuffer, { idPrefix: `lc-mf${index}-` });
+    const svgBytes = svg ? Buffer.from(svg, 'utf-8') : null;
+    if (!svgBytes || svgBytes.length > MAX_SVG_BYTES) {
+      return null;
+    }
+    return 'data:image/svg+xml;base64,' + svgBytes.toString('base64');
+  } catch (err) {
+    logger.debug(`[pptx] skipping unconvertible metafile: ${(err as Error).message}`);
+    return null;
+  }
+}
+
+/**
+ * Convert the EMF/WMF media of a PPTX to SVG data URIs, keyed by
+ * `metafileKey` of the entry's base64 (what pptx-preview puts in `img.src`).
+ * Never rejects; unreadable zips and corrupt metafiles yield fewer entries.
+ */
+export function extractPptxMetafileSvgs(buffer: Buffer): Promise<Record<string, string>> {
+  return new Promise((resolve) => {
+    yauzl.fromBuffer(buffer, { lazyEntries: true }, (err, zipfile) => {
+      if (err || !zipfile) {
+        return resolve({});
+      }
+      const result: Record<string, string> = {};
+      let considered = 0;
+      let totalSvgBytes = 0;
+      let totalMetafileBytes = 0;
+      const startedAt = Date.now();
+      let settled = false;
+      const finish = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        try {
+          zipfile.close();
+        } catch {
+          /* best-effort, as in extractPptxSlideXml */
+        }
+        resolve(result);
+      };
+
+      zipfile.on('entry', async (entry: yauzl.Entry) => {
+        try {
+          if (
+            !/\/$/.test(entry.fileName) &&
+            METAFILE_NAME.test(entry.fileName) &&
+            considered < MAX_METAFILES &&
+            entry.uncompressedSize <= MAX_METAFILE_BYTES
+          ) {
+            totalMetafileBytes += entry.uncompressedSize;
+            if (
+              totalMetafileBytes > MAX_TOTAL_METAFILE_BYTES ||
+              Date.now() - startedAt > MAX_CONVERT_MS
+            ) {
+              return finish();
+            }
+            const index = considered++;
+            const bytes = await readEntryBuffer(zipfile, entry);
+            const uri = bytes && (await convertToDataUri(bytes, index));
+            if (bytes && uri && totalSvgBytes + uri.length <= MAX_TOTAL_SVG_BYTES) {
+              totalSvgBytes += uri.length;
+              result[metafileKey(bytes.toString('base64'))] = uri;
+            }
+          }
+        } catch (e) {
+          logger.debug(`[pptx] metafile extraction error: ${(e as Error).message}`);
+        }
+        zipfile.readEntry();
+      });
+      zipfile.on('end', finish);
+      zipfile.on('error', finish);
+      zipfile.readEntry();
+    });
+  });
+}