@open-file-viewer/core 0.1.23 → 0.1.25

package/README.md

@@ -24,6 +24,15 @@ PDF preview requires `pdfjs-dist`:
 npm install pdfjs-dist
 ```
 
+### Vite / Rollup dependency chunks
+
+Text grammars, Markdown, and email parsers load asynchronously when their plugins are first used.
+Prism language chunks are loaded in dependency order, so applications do not need to preload parent
+grammars such as Java before Scala. In monorepos, `resolve.dedupe: ["prismjs"]` prevents duplicate
+Prism runtimes. Keep `/prismjs/components/` out of catch-all vendor `manualChunks` rules so the
+side-effectful language modules remain separate on-demand chunks and execute in dependency order.
+`postal-mime` and `@kenjiuno/msgreader` may optionally share an `ofv-email` chunk.
+
 DWG geometry preview uses optional LibreDWG WASM. The package can be installed by applications that want the default built-in DWG linework path:
 
 ```bash

package/dist/cpp-EDJNJWGR.js

@@ -0,0 +1,4 @@
+// src/plugins/prism-languages/cpp.ts
+import "prismjs/components/prism-c";
+import "prismjs/components/prism-cpp";
+//# sourceMappingURL=cpp-EDJNJWGR.js.map

package/dist/cpp-EDJNJWGR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/plugins/prism-languages/cpp.ts"],"sourcesContent":["import \"prismjs/components/prism-c\";\nimport \"prismjs/components/prism-cpp\";\n"],"mappings":";AAAA,OAAO;AACP,OAAO;","names":[]}

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,62 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/plugins/prism-languages/tsx.ts
+var tsx_exports = {};
+var import_prism_jsx, import_prism_typescript, import_prism_tsx;
+var init_tsx = __esm({
+  "src/plugins/prism-languages/tsx.ts"() {
+    "use strict";
+    import_prism_jsx = require("prismjs/components/prism-jsx");
+    import_prism_typescript = require("prismjs/components/prism-typescript");
+    import_prism_tsx = require("prismjs/components/prism-tsx");
+  }
+});
+
+// src/plugins/prism-languages/json5.ts
+var json5_exports = {};
+var import_prism_json, import_prism_json5;
+var init_json5 = __esm({
+  "src/plugins/prism-languages/json5.ts"() {
+    "use strict";
+    import_prism_json = require("prismjs/components/prism-json");
+    import_prism_json5 = require("prismjs/components/prism-json5");
+  }
+});
+
+// src/plugins/prism-languages/scala.ts
+var scala_exports = {};
+var import_prism_java, import_prism_scala;
+var init_scala = __esm({
+  "src/plugins/prism-languages/scala.ts"() {
+    "use strict";
+    import_prism_java = require("prismjs/components/prism-java");
+    import_prism_scala = require("prismjs/components/prism-scala");
+  }
+});
+
+// src/plugins/prism-languages/cpp.ts
+var cpp_exports = {};
+var import_prism_c, import_prism_cpp;
+var init_cpp = __esm({
+  "src/plugins/prism-languages/cpp.ts"() {
+    "use strict";
+    import_prism_c = require("prismjs/components/prism-c");
+    import_prism_cpp = require("prismjs/components/prism-cpp");
+  }
+});
+
+// src/plugins/prism-languages/php.ts
+var php_exports = {};
+var import_prism_markup_templating, import_prism_php;
+var init_php = __esm({
+  "src/plugins/prism-languages/php.ts"() {
+    "use strict";
+    import_prism_markup_templating = require("prismjs/components/prism-markup-templating");
+    import_prism_php = require("prismjs/components/prism-php");
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -4291,6 +4350,7 @@ var mimeLangMap = {
 };
 var MAX_HIGHLIGHT_CHARS = 18e4;
 var MAX_RENDER_CHARS = 6e5;
+var prismLanguageLoads = /* @__PURE__ */ new Map();
 function textPlugin() {
   return {
     name: "text",
@@ -4322,10 +4382,10 @@ function textPlugin() {
         ]);
         const parseMarkdown = markedModule.marked?.parse || markedModule.parse || markedModule.default?.parse;
         const Prism2 = PrismModule2.default || PrismModule2;
-        const DOMPurify4 = DOMPurifyModule.default || DOMPurifyModule;
+        const DOMPurify3 = DOMPurifyModule.default || DOMPurifyModule;
         const container = document.createElement("div");
         container.className = "ofv-markdown-body";
-        container.innerHTML = DOMPurify4.sanitize(parseMarkdown(text), {
+        container.innerHTML = DOMPurify3.sanitize(parseMarkdown(text), {
           USE_PROFILES: { html: true },
           ADD_ATTR: ["target"]
         });
@@ -4334,6 +4394,14 @@ function textPlugin() {
         try {
           const codeBlocks = container.querySelectorAll("pre code");
           if (codeBlocks.length > 0) {
+            const languages = /* @__PURE__ */ new Set();
+            codeBlocks.forEach((block) => {
+              const language = getPrismLanguageFromElement(block) || getPrismLanguageFromElement(block.parentElement);
+              if (language) {
+                languages.add(language);
+              }
+            });
+            await Promise.all([...languages].map((language) => loadPrismLanguage(language)));
             codeBlocks.forEach((block) => {
               const parent = block.parentElement;
               if (parent && !parent.className.includes("language-")) {
@@ -4362,97 +4430,7 @@ function textPlugin() {
       const Prism = PrismModule.default || PrismModule;
       if (lang !== "none") {
         try {
-          if (lang === "typescript" || lang === "tsx") {
-            await import("prismjs/components/prism-typescript");
-          } else if (lang === "python") {
-            await import("prismjs/components/prism-python");
-          } else if (lang === "json") {
-            await import("prismjs/components/prism-json");
-          } else if (lang === "json5") {
-            await import("prismjs/components/prism-json5");
-          } else if (lang === "yaml") {
-            await import("prismjs/components/prism-yaml");
-          } else if (lang === "toml") {
-            await import("prismjs/components/prism-toml");
-          } else if (lang === "ini") {
-            await import("prismjs/components/prism-ini");
-          } else if (lang === "properties") {
-            await import("prismjs/components/prism-properties");
-          } else if (lang === "editorconfig") {
-            await import("prismjs/components/prism-editorconfig");
-          } else if (lang === "ignore") {
-            await import("prismjs/components/prism-ignore");
-          } else if (lang === "protobuf") {
-            await import("prismjs/components/prism-protobuf");
-          } else if (lang === "hcl") {
-            await import("prismjs/components/prism-hcl");
-          } else if (lang === "latex") {
-            await import("prismjs/components/prism-latex");
-          } else if (lang === "dot") {
-            await import("prismjs/components/prism-dot");
-          } else if (lang === "http") {
-            await import("prismjs/components/prism-http");
-          } else if (lang === "bash") {
-            await import("prismjs/components/prism-bash");
-          } else if (lang === "powershell") {
-            await import("prismjs/components/prism-powershell");
-          } else if (lang === "batch") {
-            await import("prismjs/components/prism-batch");
-          } else if (lang === "docker") {
-            await import("prismjs/components/prism-docker");
-          } else if (lang === "makefile") {
-            await import("prismjs/components/prism-makefile");
-          } else if (lang === "ruby") {
-            await import("prismjs/components/prism-ruby");
-          } else if (lang === "nginx") {
-            await import("prismjs/components/prism-nginx");
-          } else if (lang === "groovy") {
-            await import("prismjs/components/prism-groovy");
-          } else if (lang === "graphql") {
-            await import("prismjs/components/prism-graphql");
-          } else if (lang === "csharp") {
-            await import("prismjs/components/prism-csharp");
-          } else if (lang === "rust") {
-            await import("prismjs/components/prism-rust");
-          } else if (lang === "go") {
-            await import("prismjs/components/prism-go");
-          } else if (lang === "ruby") {
-            await import("prismjs/components/prism-ruby");
-          } else if (lang === "swift") {
-            await import("prismjs/components/prism-swift");
-          } else if (lang === "kotlin") {
-            await import("prismjs/components/prism-kotlin");
-          } else if (lang === "scala") {
-            await import("prismjs/components/prism-scala");
-          } else if (lang === "lua") {
-            await import("prismjs/components/prism-lua");
-          } else if (lang === "r") {
-            await import("prismjs/components/prism-r");
-          } else if (lang === "dart") {
-            await import("prismjs/components/prism-dart");
-          } else if (lang === "elm") {
-            await import("prismjs/components/prism-elm");
-          } else if (lang === "elixir") {
-            await import("prismjs/components/prism-elixir");
-          } else if (lang === "clojure") {
-            await import("prismjs/components/prism-clojure");
-          } else if (lang === "erlang") {
-            await import("prismjs/components/prism-erlang");
-          } else if (lang === "fsharp") {
-            await import("prismjs/components/prism-fsharp");
-          } else if (lang === "haskell") {
-            await import("prismjs/components/prism-haskell");
-          } else if (lang === "sql") {
-            await import("prismjs/components/prism-sql");
-          } else if (lang === "cpp") {
-            await import("prismjs/components/prism-c");
-            await import("prismjs/components/prism-cpp");
-          } else if (lang === "java") {
-            await import("prismjs/components/prism-java");
-          } else if (lang === "php") {
-            await import("prismjs/components/prism-markup-templating");
-            await import("prismjs/components/prism-php");
-          }
+          await loadPrismLanguage(lang);
         } catch (e) {
           console.warn(`Prism failed to load language component for: ${lang}`, e);
         }
@@ -4577,6 +4555,183 @@ function textPlugin() {
     }
   };
 }
+function getPrismLanguageFromElement(element) {
+  if (!element) {
+    return void 0;
+  }
+  for (const className of element.classList) {
+    if (className.startsWith("language-") && className.length > 9) {
+      return className.slice(9).toLowerCase();
+    }
+  }
+  return void 0;
+}
+async function loadPrismLanguage(language) {
+  if (["none", "plain", "plaintext", "text", "markup", "css", "clike", "javascript"].includes(language)) {
+    return;
+  }
+  const existing = prismLanguageLoads.get(language);
+  if (existing) {
+    return existing;
+  }
+  const loading = loadPrismLanguageComponent(language).catch((error) => {
+    prismLanguageLoads.delete(language);
+    throw error;
+  });
+  prismLanguageLoads.set(language, loading);
+  return loading;
+}
+async function loadPrismLanguageComponent(language) {
+  switch (language) {
+    case "typescript":
+      await import("prismjs/components/prism-typescript");
+      break;
+    case "jsx":
+      await import("prismjs/components/prism-jsx");
+      break;
+    case "tsx":
+      await Promise.resolve().then(() => (init_tsx(), tsx_exports));
+      break;
+    case "python":
+      await import("prismjs/components/prism-python");
+      break;
+    case "json":
+      await import("prismjs/components/prism-json");
+      break;
+    case "json5":
+      await Promise.resolve().then(() => (init_json5(), json5_exports));
+      break;
+    case "yaml":
+      await import("prismjs/components/prism-yaml");
+      break;
+    case "toml":
+      await import("prismjs/components/prism-toml");
+      break;
+    case "ini":
+      await import("prismjs/components/prism-ini");
+      break;
+    case "properties":
+      await import("prismjs/components/prism-properties");
+      break;
+    case "editorconfig":
+      await import("prismjs/components/prism-editorconfig");
+      break;
+    case "ignore":
+      await import("prismjs/components/prism-ignore");
+      break;
+    case "protobuf":
+      await import("prismjs/components/prism-protobuf");
+      break;
+    case "hcl":
+      await import("prismjs/components/prism-hcl");
+      break;
+    case "latex":
+      await import("prismjs/components/prism-latex");
+      break;
+    case "dot":
+      await import("prismjs/components/prism-dot");
+      break;
+    case "http":
+      await import("prismjs/components/prism-http");
+      break;
+    case "bash":
+      await import("prismjs/components/prism-bash");
+      break;
+    case "powershell":
+      await import("prismjs/components/prism-powershell");
+      break;
+    case "batch":
+      await import("prismjs/components/prism-batch");
+      break;
+    case "docker":
+      await import("prismjs/components/prism-docker");
+      break;
+    case "makefile":
+      await import("prismjs/components/prism-makefile");
+      break;
+    case "ruby":
+      await import("prismjs/components/prism-ruby");
+      break;
+    case "nginx":
+      await import("prismjs/components/prism-nginx");
+      break;
+    case "groovy":
+      await import("prismjs/components/prism-groovy");
+      break;
+    case "graphql":
+      await import("prismjs/components/prism-graphql");
+      break;
+    case "csharp":
+      await import("prismjs/components/prism-csharp");
+      break;
+    case "rust":
+      await import("prismjs/components/prism-rust");
+      break;
+    case "go":
+      await import("prismjs/components/prism-go");
+      break;
+    case "swift":
+      await import("prismjs/components/prism-swift");
+      break;
+    case "kotlin":
+      await import("prismjs/components/prism-kotlin");
+      break;
+    case "java":
+      await import("prismjs/components/prism-java");
+      break;
+    case "scala":
+      await Promise.resolve().then(() => (init_scala(), scala_exports));
+      break;
+    case "lua":
+      await import("prismjs/components/prism-lua");
+      break;
+    case "r":
+      await import("prismjs/components/prism-r");
+      break;
+    case "dart":
+      await import("prismjs/components/prism-dart");
+      break;
+    case "elm":
+      await import("prismjs/components/prism-elm");
+      break;
+    case "elixir":
+      await import("prismjs/components/prism-elixir");
+      break;
+    case "clojure":
+      await import("prismjs/components/prism-clojure");
+      break;
+    case "erlang":
+      await import("prismjs/components/prism-erlang");
+      break;
+    case "fsharp":
+      await import("prismjs/components/prism-fsharp");
+      break;
+    case "haskell":
+      await import("prismjs/components/prism-haskell");
+      break;
+    case "sql":
+      await import("prismjs/components/prism-sql");
+      break;
+    case "c":
+      await import("prismjs/components/prism-c");
+      break;
+    case "cpp":
+      await Promise.resolve().then(() => (init_cpp(), cpp_exports));
+      break;
+    case "scss":
+      await import("prismjs/components/prism-scss");
+      break;
+    case "less":
+      await import("prismjs/components/prism-less");
+      break;
+    case "markup-templating":
+      await import("prismjs/components/prism-markup-templating");
+      break;
+    case "php":
+      await Promise.resolve().then(() => (init_php(), php_exports));
+      break;
+  }
+}
 function createTextZoomController(target, cssVariable, ctx) {
   let zoom = getInitialZoom(ctx, 0.5, 3);
   const apply = () => {
@@ -10423,6 +10578,7 @@ async function renderPptx(panel, arrayBuffer) {
   container.className = "ofv-pptx-viewer";
   let insight;
   let zip;
+  let placeholderFontCorrections = [];
   try {
     zip = await import_jszip3.default.loadAsync(arrayBuffer);
     insight = await inspectPptxPresentation(zip);
@@ -10430,11 +10586,18 @@ async function renderPptx(panel, arrayBuffer) {
   } catch (error) {
     console.warn("PPTX structure insight extraction failed:", error);
   }
+  if (zip) {
+    try {
+      placeholderFontCorrections = await inspectPptxPlaceholderFontCorrections(zip);
+    } catch (error) {
+      console.warn("PPTX placeholder font extraction failed:", error);
+    }
+  }
   panel.append(container);
   try {
     const { PptxViewer } = await import("@aiden0z/pptx-renderer");
     await withTimeout(PptxViewer.open(arrayBuffer, container), pptxRenderTimeoutMs());
-    normalizePptxLayout(container);
+    normalizePptxLayout(container, placeholderFontCorrections);
   } catch (error) {
     container.replaceChildren();
     if (insight) {
@@ -10486,15 +10649,168 @@ function pptxRenderTimeoutMs() {
   const override = globalThis.__OFV_PPTX_RENDER_TIMEOUT_MS__;
   return typeof override === "number" && override > 0 ? override : DEFAULT_PPTX_RENDER_TIMEOUT_MS;
 }
-function normalizePptxLayout(container) {
+function normalizePptxLayout(container, placeholderFontCorrections) {
   const slideCanvases = findPptxSlideCanvases(container);
   for (const slide of slideCanvases) {
     if (!hasInlineBackground(slide)) {
       slide.style.backgroundColor = "#FFFFFF";
     }
   }
+  normalizePptxPlaceholderFonts(container, placeholderFontCorrections);
   normalizePptxMirroredText(container);
 }
+async function inspectPptxPlaceholderFontCorrections(zip) {
+  const presentationXml = await zip.file("ppt/presentation.xml")?.async("text");
+  const presentation = presentationXml ? parseOfficeXml(presentationXml) : void 0;
+  const slideSize = presentation ? Array.from(presentation.getElementsByTagName("*")).find((element) => element.localName === "sldSz") : void 0;
+  const slideWidth = Number(slideSize?.getAttribute("cx"));
+  const slideHeight = Number(slideSize?.getAttribute("cy"));
+  if (!(slideWidth > 0) || !(slideHeight > 0)) {
+    return [];
+  }
+  const slideEntries = Object.values(zip.files).filter((entry) => !entry.dir && /^ppt\/slides\/slide\d+\.xml$/i.test(entry.name)).sort((a, b) => slideNumberFromPath(a.name) - slideNumberFromPath(b.name));
+  const corrections = [];
+  for (const [slideIndex, entry] of slideEntries.entries()) {
+    const slideXml = await entry.async("text");
+    const slide = parseOfficeXml(slideXml);
+    if (!slide) {
+      continue;
+    }
+    const relationships = await readPptxRelationships(zip, entry.name);
+    const layoutTarget = resolvePptxRelationshipTarget(
+      entry.name,
+      relationships.find((relationship) => /\/slideLayout$/i.test(relationship.type))?.target
+    );
+    const layoutXml = layoutTarget ? await zip.file(layoutTarget)?.async("text") : void 0;
+    const layout = layoutXml ? parseOfficeXml(layoutXml) : void 0;
+    if (!layout) {
+      continue;
+    }
+    const layoutFontSizes = readPptxLayoutPlaceholderFontSizes(layout);
+    const shapes = Array.from(slide.getElementsByTagName("*")).filter((element) => element.localName === "sp");
+    for (const shape of shapes) {
+      const placeholder = findPptxDescendant(shape, "ph");
+      const placeholderIndex = placeholder?.getAttribute("idx");
+      const fontSizePt = placeholderIndex ? layoutFontSizes.get(placeholderIndex) : void 0;
+      const textBody = findPptxDescendant(shape, "txBody");
+      if (!textBody?.textContent?.trim() || !fontSizePt || hasExplicitPptxTextSize(textBody)) {
+        continue;
+      }
+      const transform = findPptxDescendant(shape, "xfrm");
+      const offset = transform ? findPptxChild(transform, "off") : void 0;
+      const extent = transform ? findPptxChild(transform, "ext") : void 0;
+      const left = Number(offset?.getAttribute("x"));
+      const top = Number(offset?.getAttribute("y"));
+      const width = Number(extent?.getAttribute("cx"));
+      const height = Number(extent?.getAttribute("cy"));
+      if (![left, top, width, height].every((value) => Number.isFinite(value)) || width <= 0 || height <= 0) {
+        continue;
+      }
+      corrections.push({
+        slideIndex,
+        leftRatio: left / slideWidth,
+        topRatio: top / slideHeight,
+        widthRatio: width / slideWidth,
+        heightRatio: height / slideHeight,
+        fontSizePt
+      });
+    }
+  }
+  return corrections;
+}
+function readPptxLayoutPlaceholderFontSizes(layout) {
+  const result = /* @__PURE__ */ new Map();
+  const shapes = Array.from(layout.getElementsByTagName("*")).filter((element) => element.localName === "sp");
+  for (const shape of shapes) {
+    const placeholderIndex = findPptxDescendant(shape, "ph")?.getAttribute("idx");
+    if (!placeholderIndex) {
+      continue;
+    }
+    const textBody = findPptxDescendant(shape, "txBody");
+    const defaultRunProperties = textBody ? Array.from(textBody.getElementsByTagName("*")).find(
+      (element) => element.localName === "defRPr" && Number(element.getAttribute("sz")) > 0
+    ) : void 0;
+    const size = Number(defaultRunProperties?.getAttribute("sz"));
+    if (size > 0) {
+      result.set(placeholderIndex, size / 100);
+    }
+  }
+  return result;
+}
+function hasExplicitPptxTextSize(textBody) {
+  return Array.from(textBody.getElementsByTagName("*")).some(
+    (element) => (element.localName === "rPr" || element.localName === "defRPr" || element.localName === "endParaRPr") && Number(element.getAttribute("sz")) > 0
+  );
+}
+function findPptxDescendant(element, localName) {
+  return Array.from(element.getElementsByTagName("*")).find((child) => child.localName === localName);
+}
+function findPptxChild(element, localName) {
+  return Array.from(element.children).find((child) => child.localName === localName);
+}
+function normalizePptxPlaceholderFonts(container, corrections) {
+  for (const correction of corrections) {
+    const wrapper = container.querySelector(`div[data-slide-index="${correction.slideIndex}"]`);
+    if (!wrapper) {
+      continue;
+    }
+    const match = findPptxPlaceholderElement(wrapper, correction);
+    if (!match) {
+      continue;
+    }
+    const styledText = Array.from(match.querySelectorAll("[style]")).filter(
+      (element) => parseFloat(element.style.fontSize) > 0
+    );
+    for (const element of styledText) {
+      element.style.fontSize = `${correction.fontSizePt}pt`;
+    }
+    if (styledText.length > 0) {
+      match.dataset.ofvPptxPlaceholderFont = String(correction.fontSizePt);
+    }
+  }
+}
+function findPptxPlaceholderElement(wrapper, correction) {
+  let best;
+  for (const canvas of findPptxSlideCanvases(wrapper)) {
+    const canvasWidth = parseCssPixelValue(canvas.style.width);
+    const canvasHeight = parseCssPixelValue(canvas.style.height);
+    if (!(canvasWidth > 0) || !(canvasHeight > 0)) {
+      continue;
+    }
+    const expected = {
+      left: correction.leftRatio * canvasWidth,
+      top: correction.topRatio * canvasHeight,
+      width: correction.widthRatio * canvasWidth,
+      height: correction.heightRatio * canvasHeight
+    };
+    const candidates = Array.from(canvas.querySelectorAll("div")).filter(
+      (element) => element.style.position === "absolute" && Boolean(element.textContent?.trim())
+    );
+    for (const element of candidates) {
+      const actual = {
+        left: parseCssPixelValue(element.style.left),
+        top: parseCssPixelValue(element.style.top),
+        width: parseCssPixelValue(element.style.width),
+        height: parseCssPixelValue(element.style.height)
+      };
+      const deltas = [
+        Math.abs(actual.left - expected.left),
+        Math.abs(actual.top - expected.top),
+        Math.abs(actual.width - expected.width),
+        Math.abs(actual.height - expected.height)
+      ];
+      const tolerance = Math.max(2, Math.min(canvasWidth, canvasHeight) * 5e-3);
+      if (deltas.some((delta) => delta > tolerance)) {
+        continue;
+      }
+      const score = deltas.reduce((sum, delta) => sum + delta, 0);
+      if (!best || score < best.score) {
+        best = { element, score };
+      }
+    }
+  }
+  return best?.element;
+}
 function hasInlineBackground(element) {
   return Boolean(element.style.background || element.style.backgroundColor || element.style.backgroundImage);
 }
@@ -12988,9 +13304,9 @@ function getIcon(name, dir) {
 }
 
 // src/plugins/email.ts
-var import_dompurify3 = __toESM(require("dompurify"), 1);
 var emailExtensions = /* @__PURE__ */ new Set(["eml", "msg", "mbox"]);
 var emailMimeTypes = /* @__PURE__ */ new Set(["message/rfc822", "application/vnd.ms-outlook", "application/mbox"]);
+var domPurifyLoader;
 var emailMimeFormatMap = {
   "message/rfc822": "eml",
   "application/vnd.ms-outlook": "msg",
@@ -13003,6 +13319,8 @@ function emailPlugin() {
       return emailExtensions.has(file.extension) || emailMimeTypes.has(file.mimeType);
     },
     async render(ctx) {
+      const DOMPurifyModule = await (domPurifyLoader ||= import("dompurify"));
+      const DOMPurify3 = DOMPurifyModule.default;
       const panel = createPanel("ofv-email");
       ctx.viewport.append(panel);
       const url = createObjectUrl(ctx.file);
@@ -13136,7 +13454,7 @@ function emailPlugin() {
             }
           });
           html = nextHtml;
-          const sanitizedHtml = sanitizeEmailHtml(html);
+          const sanitizedHtml = sanitizeEmailHtml(html, DOMPurify3);
           const iframe = document.createElement("iframe");
           iframe.className = "ofv-email-body-iframe";
           iframe.setAttribute("sandbox", "allow-same-origin allow-popups allow-popups-to-escape-sandbox");
@@ -13429,8 +13747,8 @@ function getMimeType(name) {
   };
   return ext ? map[ext] || "application/octet-stream" : "application/octet-stream";
 }
-function sanitizeEmailHtml(html) {
-  return import_dompurify3.default.sanitize(html, {
+function sanitizeEmailHtml(html, purifier) {
+  return purifier.sanitize(html, {
     USE_PROFILES: { html: true },
     ADD_ATTR: ["target"],
     ALLOWED_URI_REGEXP: /^(?:(?:https?|mailto|tel|blob|cid):|[^a-z]|[a-z+.-]+(?:[^a-z+.-:]|$))/i