pptx-glimpse 3.0.0 → 3.1.0

package/dist/index.cjs

@@ -929,84 +929,6 @@ var init_cjk_font_fallback = __esm({
   }
 });
 
-// ../renderer/src/unsafe-type-assertion.ts
-function unsafeExternalInteropAssertion(value) {
-  return value;
-}
-function unsafeBrandAssertion(value) {
-  return value;
-}
-var init_unsafe_type_assertion = __esm({
-  "../renderer/src/unsafe-type-assertion.ts"() {
-    "use strict";
-  }
-});
-
-// ../renderer/src/warning-logger.ts
-function initWarningLogger(level) {
-  currentLevel = level;
-  entries = [];
-  featureCounts.clear();
-}
-function warn(feature, message, context) {
-  if (currentLevel === "off") return;
-  entries.push({ feature, message, ...context !== void 0 && { context } });
-  const existing = featureCounts.get(feature);
-  if (existing) {
-    existing.count++;
-  } else {
-    featureCounts.set(feature, { message, count: 1 });
-  }
-  if (currentLevel === "debug") {
-    const ctx = context ? ` (${context})` : "";
-    console.warn(`${PREFIX} SKIP: ${feature} - ${message}${ctx}`);
-  }
-}
-function debug(feature, message, context) {
-  if (currentLevel !== "debug") return;
-  entries.push({ feature, message, ...context !== void 0 && { context } });
-  const existing = featureCounts.get(feature);
-  if (existing) {
-    existing.count++;
-  } else {
-    featureCounts.set(feature, { message, count: 1 });
-  }
-  const ctx = context ? ` (${context})` : "";
-  console.warn(`${PREFIX} DEBUG: ${feature} - ${message}${ctx}`);
-}
-function getWarningSummary() {
-  const features = [];
-  for (const [feature, { message, count }] of featureCounts) {
-    features.push({ feature, message, count });
-  }
-  return { totalCount: entries.length, features };
-}
-function flushWarnings() {
-  const summary = getWarningSummary();
-  if (currentLevel !== "off" && summary.features.length > 0) {
-    console.warn(`${PREFIX} Summary: ${summary.features.length} unsupported feature(s) detected`);
-    for (const { feature, count } of summary.features) {
-      console.warn(`  - ${feature}: ${count} occurrence(s)`);
-    }
-  }
-  entries = [];
-  featureCounts.clear();
-  return summary;
-}
-function getWarningEntries() {
-  return entries;
-}
-var PREFIX, currentLevel, entries, featureCounts;
-var init_warning_logger = __esm({
-  "../renderer/src/warning-logger.ts"() {
-    "use strict";
-    PREFIX = "[pptx-glimpse]";
-    currentLevel = "off";
-    entries = [];
-    featureCounts = /* @__PURE__ */ new Map();
-  }
-});
-
 // ../renderer/src/font/font-mapping.ts
 function createFontMapping(userMapping) {
   if (!userMapping) return { ...DEFAULT_FONT_MAPPING };
@@ -1068,11 +990,8 @@ var init_font_mapping = __esm({
 });
 
 // ../renderer/src/font/font-mapping-context.ts
-function setFontMapping(mapping) {
-  currentMapping = mapping;
-}
-function resetFontMapping() {
-  currentMapping = { ...DEFAULT_FONT_MAPPING };
+function getFontMapping() {
+  return currentMapping;
 }
 function getCurrentMappedFont(fontFamily) {
   return getMappedFont(fontFamily, currentMapping);
@@ -1184,6 +1103,169 @@ var init_text_measure = __esm({
   }
 });
 
+// ../renderer/src/warning-logger.ts
+function createWarningLogger(level) {
+  return new InMemoryWarningLogger(level);
+}
+function getActiveWarningLogger() {
+  return activeLogger;
+}
+function warn(feature, message, context) {
+  activeLogger.warn(feature, message, context);
+}
+function getWarningSummary() {
+  return activeLogger.getWarningSummary();
+}
+function getWarningEntries() {
+  return activeLogger.getWarningEntries();
+}
+var PREFIX, InMemoryWarningLogger, activeLogger;
+var init_warning_logger = __esm({
+  "../renderer/src/warning-logger.ts"() {
+    "use strict";
+    PREFIX = "[pptx-glimpse]";
+    InMemoryWarningLogger = class {
+      constructor(level) {
+        this.level = level;
+      }
+      level;
+      entries = [];
+      featureCounts = /* @__PURE__ */ new Map();
+      warn(feature, message, context) {
+        if (this.level === "off") return;
+        this.record(feature, message, context);
+        if (this.level === "debug") {
+          const ctx = context ? ` (${context})` : "";
+          console.warn(`${PREFIX} SKIP: ${feature} - ${message}${ctx}`);
+        }
+      }
+      debug(feature, message, context) {
+        if (this.level !== "debug") return;
+        this.record(feature, message, context);
+        const ctx = context ? ` (${context})` : "";
+        console.warn(`${PREFIX} DEBUG: ${feature} - ${message}${ctx}`);
+      }
+      getWarningSummary() {
+        const features = [];
+        for (const [feature, { message, count }] of this.featureCounts) {
+          features.push({ feature, message, count });
+        }
+        return { totalCount: this.entries.length, features };
+      }
+      flushWarnings() {
+        const summary = this.getWarningSummary();
+        if (this.level !== "off" && summary.features.length > 0) {
+          console.warn(`${PREFIX} Summary: ${summary.features.length} unsupported feature(s) detected`);
+          for (const { feature, count } of summary.features) {
+            console.warn(`  - ${feature}: ${count} occurrence(s)`);
+          }
+        }
+        this.entries = [];
+        this.featureCounts.clear();
+        return summary;
+      }
+      getWarningEntries() {
+        return this.entries;
+      }
+      getLogLevel() {
+        return this.level;
+      }
+      record(feature, message, context) {
+        this.entries.push({ feature, message, ...context !== void 0 && { context } });
+        const existing = this.featureCounts.get(feature);
+        if (existing) {
+          existing.count++;
+        } else {
+          this.featureCounts.set(feature, { message, count: 1 });
+        }
+      }
+    };
+    activeLogger = createWarningLogger("off");
+  }
+});
+
+// ../renderer/src/font/text-path-context.ts
+function getTextPathFontResolver() {
+  return currentResolver;
+}
+var DefaultTextPathFontResolver, currentResolver;
+var init_text_path_context = __esm({
+  "../renderer/src/font/text-path-context.ts"() {
+    "use strict";
+    init_warning_logger();
+    init_cjk_font_fallback();
+    init_font_mapping();
+    init_font_mapping_context();
+    DefaultTextPathFontResolver = class {
+      fonts;
+      defaultFont;
+      warnedFonts = /* @__PURE__ */ new Set();
+      constructor(fonts, defaultFont) {
+        this.fonts = fonts;
+        this.defaultFont = defaultFont ?? null;
+      }
+      resolveFont(fontFamily, fontFamilyEa, jpanFallback, context) {
+        if (fontFamily) {
+          const font = this.findFont(fontFamily, context);
+          if (font) return font;
+        }
+        if (fontFamilyEa) {
+          const font = this.findFont(fontFamilyEa, context);
+          if (font) return font;
+        }
+        if (jpanFallback) {
+          const font = this.findFont(jpanFallback, context);
+          if (font) return font;
+        }
+        for (const name of [fontFamily, fontFamilyEa, jpanFallback]) {
+          if (name) {
+            const logger = context?.warningLogger;
+            if (logger) {
+              if (context.fontWarningCache?.has(name)) continue;
+              context.fontWarningCache?.add(name);
+              logger.warn("font.notFound", `Font not found: "${name}"`);
+              continue;
+            }
+            if (!this.warnedFonts.has(name)) {
+              this.warnedFonts.add(name);
+              warn("font.notFound", `Font not found: "${name}"`);
+            }
+          }
+        }
+        return this.defaultFont;
+      }
+      findFont(name, context) {
+        const direct = this.fonts.get(name);
+        if (direct) return direct;
+        const mapped = context?.fontMapping !== void 0 ? getMappedFont(name, context.fontMapping) : getCurrentMappedFont(name);
+        if (mapped) {
+          const mappedFont = this.fonts.get(mapped);
+          if (mappedFont) return mappedFont;
+          for (const fallback of getCjkFallbackFonts(mapped)) {
+            const fallbackFont = this.fonts.get(fallback);
+            if (fallbackFont) return fallbackFont;
+          }
+        }
+        return null;
+      }
+    };
+    currentResolver = null;
+  }
+});
+
+// ../renderer/src/unsafe-type-assertion.ts
+function unsafeExternalInteropAssertion(value) {
+  return value;
+}
+function unsafeBrandAssertion(value) {
+  return value;
+}
+var init_unsafe_type_assertion = __esm({
+  "../renderer/src/unsafe-type-assertion.ts"() {
+    "use strict";
+  }
+});
+
 // ../renderer/src/font/opentype-text-measurer.ts
 var PX_PER_PT2, BOLD_FACTOR2, OpentypeTextMeasurer;
 var init_opentype_text_measurer = __esm({
@@ -1192,24 +1274,27 @@ var init_opentype_text_measurer = __esm({
     init_text_measure();
     init_warning_logger();
     init_cjk_font_fallback();
+    init_font_mapping();
     init_font_mapping_context();
     PX_PER_PT2 = 96 / 72;
     BOLD_FACTOR2 = 1.05;
     OpentypeTextMeasurer = class {
-      fonts;
-      defaultFont;
-      warnedFonts = /* @__PURE__ */ new Set();
       /**
        * @param fonts - font name -> opentype.js Map of Font objects
        * @param defaultFont - fallback font (optional)
        */
-      constructor(fonts, defaultFont) {
+      constructor(fonts, defaultFont, fontMapping) {
+        this.fontMapping = fontMapping;
         this.fonts = fonts;
         this.defaultFont = defaultFont ?? null;
       }
-      measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa) {
-        const latinFont = this.resolveFont(fontFamily);
-        const eaFont = this.resolveFont(fontFamilyEa);
+      fontMapping;
+      fonts;
+      defaultFont;
+      warnedFonts = /* @__PURE__ */ new Set();
+      measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa, context) {
+        const latinFont = this.resolveFont(fontFamily, context);
+        const eaFont = this.resolveFont(fontFamilyEa, context);
         const fallbackFont = latinFont ?? eaFont ?? this.defaultFont;
         if (!fallbackFont) {
           return measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa);
@@ -1217,7 +1302,7 @@ var init_opentype_text_measurer = __esm({
         const fontSizePx = fontSizePt * PX_PER_PT2;
         const latinFontResolved = latinFont ?? fallbackFont;
         const eaFontResolved = eaFont ?? fallbackFont;
-        const boldLatinFont = bold ? this.resolveBoldFont(fontFamily) : null;
+        const boldLatinFont = bold ? this.resolveBoldFont(fontFamily, context) : null;
         const latinGlyphCache = /* @__PURE__ */ new Map();
         const eaGlyphCache = eaFontResolved !== latinFontResolved ? /* @__PURE__ */ new Map() : latinGlyphCache;
         const boldGlyphCache = /* @__PURE__ */ new Map();
@@ -1249,26 +1334,26 @@ var init_opentype_text_measurer = __esm({
         }
         return totalWidth;
       }
-      getLineHeightRatio(fontFamily, fontFamilyEa) {
-        const font = this.resolveFont(fontFamily) ?? this.resolveFont(fontFamilyEa) ?? this.defaultFont;
+      getLineHeightRatio(fontFamily, fontFamilyEa, context) {
+        const font = this.resolveFont(fontFamily, context) ?? this.resolveFont(fontFamilyEa, context) ?? this.defaultFont;
         if (!font) return 1.2;
         return (font.ascender + Math.abs(font.descender)) / font.unitsPerEm;
       }
-      getAscenderRatio(fontFamily, fontFamilyEa) {
-        const font = this.resolveFont(fontFamily) ?? this.resolveFont(fontFamilyEa) ?? this.defaultFont;
+      getAscenderRatio(fontFamily, fontFamilyEa, context) {
+        const font = this.resolveFont(fontFamily, context) ?? this.resolveFont(fontFamilyEa, context) ?? this.defaultFont;
         if (!font) return 1;
         return font.ascender / font.unitsPerEm;
       }
-      resolveBoldFont(name) {
+      resolveBoldFont(name, context) {
         if (!name) return null;
         const bases = [name];
-        const mappedBase = getCurrentMappedFont(name);
+        const mappedBase = this.getMappedFont(name, context);
         if (mappedBase && mappedBase !== name) bases.push(mappedBase);
         for (const base of bases) {
           for (const boldName of [`${base} Bold`, `${base}-Bold`]) {
             const direct = this.fonts.get(boldName);
             if (direct) return direct;
-            const mapped = getCurrentMappedFont(boldName);
+            const mapped = this.getMappedFont(boldName, context);
             if (mapped) {
               const mappedFont = this.fonts.get(mapped);
               if (mappedFont) return mappedFont;
@@ -1277,11 +1362,11 @@ var init_opentype_text_measurer = __esm({
         }
         return null;
       }
-      resolveFont(name) {
+      resolveFont(name, context) {
         if (!name) return null;
         const direct = this.fonts.get(name);
         if (direct) return direct;
-        const mapped = getCurrentMappedFont(name);
+        const mapped = this.getMappedFont(name, context);
         if (mapped) {
           const mappedFont = this.fonts.get(mapped);
           if (mappedFont) return mappedFont;
@@ -1290,78 +1375,20 @@ var init_opentype_text_measurer = __esm({
             if (fallbackFont) return fallbackFont;
           }
         }
-        if (!this.warnedFonts.has(name)) {
+        if (context?.warningLogger) {
+          if (context.fontWarningCache?.has(name)) return null;
+          context.fontWarningCache?.add(name);
+          context.warningLogger.warn("font.notFound", `Font not found: "${name}"`);
+        } else if (!this.warnedFonts.has(name)) {
           this.warnedFonts.add(name);
           warn("font.notFound", `Font not found: "${name}"`);
         }
         return null;
       }
-    };
-  }
-});
-
-// ../renderer/src/font/text-path-context.ts
-function setTextPathFontResolver(resolver) {
-  currentResolver = resolver;
-}
-function getTextPathFontResolver() {
-  return currentResolver;
-}
-function resetTextPathFontResolver() {
-  currentResolver = null;
-}
-var DefaultTextPathFontResolver, currentResolver;
-var init_text_path_context = __esm({
-  "../renderer/src/font/text-path-context.ts"() {
-    "use strict";
-    init_warning_logger();
-    init_cjk_font_fallback();
-    init_font_mapping_context();
-    DefaultTextPathFontResolver = class {
-      fonts;
-      defaultFont;
-      warnedFonts = /* @__PURE__ */ new Set();
-      constructor(fonts, defaultFont) {
-        this.fonts = fonts;
-        this.defaultFont = defaultFont ?? null;
-      }
-      resolveFont(fontFamily, fontFamilyEa, jpanFallback) {
-        if (fontFamily) {
-          const font = this.findFont(fontFamily);
-          if (font) return font;
-        }
-        if (fontFamilyEa) {
-          const font = this.findFont(fontFamilyEa);
-          if (font) return font;
-        }
-        if (jpanFallback) {
-          const font = this.findFont(jpanFallback);
-          if (font) return font;
-        }
-        for (const name of [fontFamily, fontFamilyEa, jpanFallback]) {
-          if (name && !this.warnedFonts.has(name)) {
-            this.warnedFonts.add(name);
-            warn("font.notFound", `Font not found: "${name}"`);
-          }
-        }
-        return this.defaultFont;
-      }
-      findFont(name) {
-        const direct = this.fonts.get(name);
-        if (direct) return direct;
-        const mapped = getCurrentMappedFont(name);
-        if (mapped) {
-          const mappedFont = this.fonts.get(mapped);
-          if (mappedFont) return mappedFont;
-          for (const fallback of getCjkFallbackFonts(mapped)) {
-            const fallbackFont = this.fonts.get(fallback);
-            if (fallbackFont) return fallbackFont;
-          }
-        }
-        return null;
+      getMappedFont(name, context) {
+        return context?.fontMapping !== void 0 ? getMappedFont(name, context.fontMapping) : this.fontMapping !== void 0 ? getMappedFont(name, this.fontMapping) : getCurrentMappedFont(name);
       }
     };
-    currentResolver = null;
   }
 });
 
@@ -1561,11 +1588,12 @@ function collectFontNames(font) {
   }
   return names;
 }
-function buildOpentypeSetupFromState(state) {
+function buildOpentypeSetupFromState(state, fontMapping) {
   if (state.measurerFonts.size === 0 && !state.firstMeasurerFont) return null;
   const measurer = new OpentypeTextMeasurer(
     state.measurerFonts,
-    state.firstMeasurerFont ?? void 0
+    state.firstMeasurerFont ?? void 0,
+    fontMapping
   );
   const fontResolver = new DefaultTextPathFontResolver(
     state.resolverFonts,
@@ -1594,7 +1622,7 @@ async function createOpentypeSetupFromBuffers(fontBuffers, fontMapping) {
     } catch {
     }
   }
-  return buildOpentypeSetupFromState(state);
+  return buildOpentypeSetupFromState(state, mapping);
 }
 function getSystemFontCacheStore() {
   const globalObject = globalThis;
@@ -1719,7 +1747,8 @@ async function createOpentypeSetupFromSystem(additionalFontDirs, fontMapping, sk
   if (!opentype) return null;
   const fontFilePaths = collectFontFilePaths(additionalFontDirs, skipSystemFonts);
   if (fontFilePaths.length === 0) return null;
-  const reverseMap = buildReverseMapping(createFontMapping(fontMapping));
+  const mapping = createFontMapping(fontMapping);
+  const reverseMap = buildReverseMapping(mapping);
   const state = createOpentypeSetupState();
   for (const filePath of fontFilePaths) {
     try {
@@ -1732,7 +1761,7 @@ async function createOpentypeSetupFromSystem(additionalFontDirs, fontMapping, sk
     } catch {
     }
   }
-  const setup = buildOpentypeSetupFromState(state);
+  const setup = buildOpentypeSetupFromState(state, mapping);
   if (setup === null) return null;
   setCachedSystemOpentypeSetup(key, setup);
   return setup;
@@ -1920,7 +1949,8 @@ __export(index_exports, {
   getMappedFont: () => getMappedFont,
   getWarningEntries: () => getWarningEntries,
   getWarningSummary: () => getWarningSummary,
-  initResvgWasm: () => initResvgWasm2
+  initResvgWasm: () => initResvgWasm2,
+  renderPptxSourceModelToSvg: () => renderPptxSourceModelToSvg2
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1928,6 +1958,98 @@ module.exports = __toCommonJS(index_exports);
 init_font_metrics();
 init_cjk_font_fallback();
 
+// ../renderer/src/renderer/render-context.ts
+init_font_mapping();
+init_font_mapping_context();
+
+// ../renderer/src/font/font-usage-collector.ts
+var FontUsageCollector = class {
+  /** key: font name at the beginning of tspan's font-family list (= name declared with @font-face) */
+  usages = /* @__PURE__ */ new Map();
+  record(fonts, text) {
+    const primary = fonts.find((f) => f !== null && f !== void 0);
+    if (!primary || text.length === 0) return;
+    let usage = this.usages.get(primary);
+    if (!usage) {
+      usage = { fonts: [...fonts], chars: /* @__PURE__ */ new Set() };
+      this.usages.set(primary, usage);
+    }
+    for (const char of text) {
+      usage.chars.add(char);
+    }
+  }
+  getUsages() {
+    return this.usages;
+  }
+  reset() {
+    this.usages.clear();
+  }
+};
+var currentCollector = null;
+function getFontUsageCollector() {
+  return currentCollector;
+}
+
+// ../renderer/src/font/script-font-context.ts
+var jpanMajorFont = null;
+var jpanMinorFont = null;
+function getScriptFonts() {
+  return { majorJpan: jpanMajorFont, minorJpan: jpanMinorFont };
+}
+function getJpanFallbackFont() {
+  return jpanMajorFont ?? jpanMinorFont;
+}
+
+// ../renderer/src/font/text-measurer.ts
+init_text_measure();
+var DefaultTextMeasurer = class {
+  measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa, _context) {
+    return measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa);
+  }
+  getLineHeightRatio(fontFamily, fontFamilyEa, _context) {
+    return getLineHeightRatio(fontFamily, fontFamilyEa);
+  }
+  getAscenderRatio(fontFamily, fontFamilyEa, _context) {
+    return getAscenderRatio(fontFamily, fontFamilyEa);
+  }
+};
+var currentMeasurer = new DefaultTextMeasurer();
+function getTextMeasurer() {
+  return currentMeasurer;
+}
+
+// ../renderer/src/renderer/render-context.ts
+init_text_path_context();
+init_warning_logger();
+function createRendererContext(overrides = {}) {
+  return {
+    textMeasurer: overrides.textMeasurer ?? new DefaultTextMeasurer(),
+    textPathFontResolver: overrides.textPathFontResolver ?? null,
+    fontMapping: overrides.fontMapping ?? { ...DEFAULT_FONT_MAPPING },
+    fontUsageCollector: overrides.fontUsageCollector ?? null,
+    scriptFonts: overrides.scriptFonts ?? { majorJpan: null, minorJpan: null },
+    warningLogger: overrides.warningLogger ?? createWarningLogger("off"),
+    fontWarningCache: overrides.fontWarningCache ?? /* @__PURE__ */ new Set()
+  };
+}
+function createLegacyRendererContext() {
+  return {
+    textMeasurer: getTextMeasurer(),
+    textPathFontResolver: getTextPathFontResolver(),
+    fontMapping: getFontMapping(),
+    fontUsageCollector: getFontUsageCollector(),
+    scriptFonts: getScriptFonts(),
+    warningLogger: getActiveWarningLogger(),
+    fontWarningCache: /* @__PURE__ */ new Set()
+  };
+}
+function getJpanFallbackFontFromContext(context) {
+  return context.scriptFonts.majorJpan ?? context.scriptFonts.minorJpan;
+}
+function getMappedFontFromContext(fontFamily, context) {
+  return getMappedFont(fontFamily, context.fontMapping);
+}
+
 // ../renderer/src/utils/base64.ts
 function uint8ArrayToBase64(data) {
   let binary = "";
@@ -1952,7 +2074,7 @@ function glyphName(glyph, firstUnicode) {
   if (glyph.name) return glyph.name;
   return `uni${firstUnicode.toString(16).toUpperCase().padStart(4, "0")}`;
 }
-async function subsetFont(font, chars, familyName) {
+async function subsetFont(font, chars, familyName, warningLogger) {
   const opentype = await tryLoadOpentypeCtors();
   if (!opentype) return null;
   const source = unsafeExternalInteropAssertion(font);
@@ -2008,44 +2130,32 @@ async function subsetFont(font, chars, familyName) {
     });
     return new Uint8Array(subset.toArrayBuffer());
   } catch (e) {
-    warn(
-      "font.subsetFailed",
-      `Failed to subset font "${familyName}": ${e instanceof Error ? e.message : String(e)}`
-    );
+    const message = `Failed to subset font "${familyName}": ${e instanceof Error ? e.message : String(e)}`;
+    if (warningLogger) {
+      warningLogger.warn("font.subsetFailed", message);
+    } else {
+      warn("font.subsetFailed", message);
+    }
     return null;
   }
 }
 
-// ../renderer/src/font/script-font-context.ts
-var jpanMajorFont = null;
-var jpanMinorFont = null;
-function setScriptFonts(majorJpan, minorJpan) {
-  jpanMajorFont = majorJpan;
-  jpanMinorFont = minorJpan;
-}
-function resetScriptFonts() {
-  jpanMajorFont = null;
-  jpanMinorFont = null;
-}
-function getJpanFallbackFont() {
-  return jpanMajorFont ?? jpanMinorFont;
-}
-
 // ../renderer/src/font/font-embedder.ts
 function escapeCssFamilyName(name) {
   return name.replace(/[\\"]/g, (c) => `\\${c}`).replace(/[<>&]/g, (c) => `\\${c.codePointAt(0).toString(16)} `);
 }
-async function buildFontFaceStyle(usages, fontResolver) {
+async function buildFontFaceStyle(usages, fontResolver, context) {
   const faces = [];
-  const jpanFallback = getJpanFallbackFont();
+  const jpanFallback = context !== void 0 ? getJpanFallbackFontFromContext(context) : getJpanFallbackFont();
   for (const [familyName, usage] of usages) {
     const font = fontResolver.resolveFont(
       usage.fonts[0],
       usage.fonts[1] ?? null,
-      usage.fonts[2] ?? jpanFallback
+      usage.fonts[2] ?? jpanFallback,
+      context
     );
     if (!font) continue;
-    const buffer = await subsetFont(font, usage.chars, familyName);
+    const buffer = await subsetFont(font, usage.chars, familyName, context?.warningLogger);
     if (!buffer) continue;
     const base64 = uint8ArrayToBase64(buffer);
     faces.push(
@@ -2059,70 +2169,8 @@ async function buildFontFaceStyle(usages, fontResolver) {
 // ../renderer/src/index.ts
 init_font_mapping();
 init_font_mapping_context();
-
-// ../renderer/src/font/font-usage-collector.ts
-var FontUsageCollector = class {
-  /** key: font name at the beginning of tspan's font-family list (= name declared with @font-face) */
-  usages = /* @__PURE__ */ new Map();
-  record(fonts, text) {
-    const primary = fonts.find((f) => f !== null && f !== void 0);
-    if (!primary || text.length === 0) return;
-    let usage = this.usages.get(primary);
-    if (!usage) {
-      usage = { fonts: [...fonts], chars: /* @__PURE__ */ new Set() };
-      this.usages.set(primary, usage);
-    }
-    for (const char of text) {
-      usage.chars.add(char);
-    }
-  }
-  getUsages() {
-    return this.usages;
-  }
-  reset() {
-    this.usages.clear();
-  }
-};
-var currentCollector = null;
-function setFontUsageCollector(collector) {
-  currentCollector = collector;
-}
-function getFontUsageCollector() {
-  return currentCollector;
-}
-function resetFontUsageCollector() {
-  currentCollector = null;
-}
-
-// ../renderer/src/index.ts
 init_opentype_buffer_helpers();
 init_opentype_text_measurer();
-
-// ../renderer/src/font/text-measurer.ts
-init_text_measure();
-var DefaultTextMeasurer = class {
-  measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa) {
-    return measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa);
-  }
-  getLineHeightRatio(fontFamily, fontFamilyEa) {
-    return getLineHeightRatio(fontFamily, fontFamilyEa);
-  }
-  getAscenderRatio(fontFamily, fontFamilyEa) {
-    return getAscenderRatio(fontFamily, fontFamilyEa);
-  }
-};
-var currentMeasurer = new DefaultTextMeasurer();
-function setTextMeasurer(measurer) {
-  currentMeasurer = measurer;
-}
-function getTextMeasurer() {
-  return currentMeasurer;
-}
-function resetTextMeasurer() {
-  currentMeasurer = new DefaultTextMeasurer();
-}
-
-// ../renderer/src/index.ts
 init_text_path_context();
 init_ttc_parser();
 
@@ -2246,9 +2294,6 @@ function round(n) {
   return Math.round(n * 1e3) / 1e3;
 }
 
-// ../renderer/src/renderer/chart-renderer.ts
-init_warning_logger();
-
 // ../renderer/src/renderer/transform.ts
 function buildTransformAttr(t) {
   const x = emuToPixels(t.offsetX);
@@ -2279,7 +2324,7 @@ var DEFAULT_SERIES_COLORS = [
   { hex: "#70AD47", alpha: 1 }
 ];
 var LEGEND_SIDE_WIDTH = 100;
-function renderChart(element) {
+function renderChart(element, context = createLegacyRendererContext()) {
   const { transform, chart } = element;
   const w = emuToPixels(transform.extentWidth);
   const h = emuToPixels(transform.extentHeight);
@@ -2307,37 +2352,37 @@ function renderChart(element) {
   if (plotW > 0 && plotH > 0) {
     switch (chart.chartType) {
       case "bar":
-        parts.push(renderBarChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderBarChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "line":
-        parts.push(renderLineChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderLineChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "pie":
-        parts.push(renderPieChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderPieChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "doughnut":
-        parts.push(renderDoughnutChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderDoughnutChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "scatter":
-        parts.push(renderScatterChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderScatterChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "bubble":
-        parts.push(renderBubbleChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderBubbleChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "area":
-        parts.push(renderAreaChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderAreaChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "radar":
-        parts.push(renderRadarChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderRadarChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "stock":
-        parts.push(renderStockChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderStockChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "surface":
-        parts.push(renderSurfaceChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderSurfaceChart(chart, plotX, plotY, plotW, plotH, context));
         break;
       case "ofPie":
-        parts.push(renderOfPieChart(chart, plotX, plotY, plotW, plotH));
+        parts.push(renderOfPieChart(chart, plotX, plotY, plotW, plotH, context));
         break;
     }
   }
@@ -2350,21 +2395,24 @@ function renderChart(element) {
 function renderChartTitle(title, chartWidth) {
   return `<text x="${round2(chartWidth / 2)}" y="20" text-anchor="middle" font-size="14" font-weight="bold" fill="#404040">${escapeXml(title)}</text>`;
 }
-function renderBarChart(chart, x, y, w, h) {
+function debugChart(context, feature, message) {
+  context.warningLogger.debug(feature, message);
+}
+function renderBarChart(chart, x, y, w, h, context) {
   const parts = [];
   const { series, categories } = chart;
   if (series.length === 0) {
-    debug("chart.bar", "series is empty");
+    debugChart(context, "chart.bar", "series is empty");
     return "";
   }
   const maxVal = getMaxValue(series);
   if (maxVal === 0) {
-    debug("chart.bar", "max value is 0");
+    debugChart(context, "chart.bar", "max value is 0");
     return "";
   }
   const catCount = categories.length || Math.max(...series.map((s) => s.values.length));
   if (catCount === 0) {
-    debug("chart.bar", "category count is 0");
+    debugChart(context, "chart.bar", "category count is 0");
     return "";
   }
   const isHorizontal = chart.barDirection === "bar";
@@ -2437,21 +2485,21 @@ function renderBarChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
-function renderLineChart(chart, x, y, w, h) {
+function renderLineChart(chart, x, y, w, h, context) {
   const parts = [];
   const { series, categories } = chart;
   if (series.length === 0) {
-    debug("chart.line", "series is empty");
+    debugChart(context, "chart.line", "series is empty");
     return "";
   }
   const maxVal = getMaxValue(series);
   if (maxVal === 0) {
-    debug("chart.line", "max value is 0");
+    debugChart(context, "chart.line", "max value is 0");
     return "";
   }
   const catCount = categories.length || Math.max(...series.map((s) => s.values.length));
   if (catCount === 0) {
-    debug("chart.line", "category count is 0");
+    debugChart(context, "chart.line", "category count is 0");
     return "";
   }
   const ticks = computeNiceTicks(0, maxVal);
@@ -2489,21 +2537,21 @@ function renderLineChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
-function renderAreaChart(chart, x, y, w, h) {
+function renderAreaChart(chart, x, y, w, h, context) {
   const parts = [];
   const { series, categories } = chart;
   if (series.length === 0) {
-    debug("chart.area", "series is empty");
+    debugChart(context, "chart.area", "series is empty");
     return "";
   }
   const maxVal = getMaxValue(series);
   if (maxVal === 0) {
-    debug("chart.area", "max value is 0");
+    debugChart(context, "chart.area", "max value is 0");
     return "";
   }
   const catCount = categories.length || Math.max(...series.map((s) => s.values.length));
   if (catCount === 0) {
-    debug("chart.area", "category count is 0");
+    debugChart(context, "chart.area", "category count is 0");
     return "";
   }
   const ticks = computeNiceTicks(0, maxVal);
@@ -2542,16 +2590,16 @@ function renderAreaChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
-function renderPieChart(chart, x, y, w, h) {
+function renderPieChart(chart, x, y, w, h, context) {
   const parts = [];
   const series = chart.series[0];
   if (!series || series.values.length === 0) {
-    debug("chart.pie", "series is empty or has no values");
+    debugChart(context, "chart.pie", "series is empty or has no values");
     return "";
   }
   const total = series.values.reduce((sum, v) => sum + v, 0);
   if (total === 0) {
-    debug("chart.pie", "total value is 0");
+    debugChart(context, "chart.pie", "total value is 0");
     return "";
   }
   const cx = x + w / 2;
@@ -2580,16 +2628,16 @@ function renderPieChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
-function renderDoughnutChart(chart, x, y, w, h) {
+function renderDoughnutChart(chart, x, y, w, h, context) {
   const parts = [];
   const series = chart.series[0];
   if (!series || series.values.length === 0) {
-    debug("chart.doughnut", "series is empty or has no values");
+    debugChart(context, "chart.doughnut", "series is empty or has no values");
     return "";
   }
   const total = series.values.reduce((sum, v) => sum + v, 0);
   if (total === 0) {
-    debug("chart.doughnut", "total value is 0");
+    debugChart(context, "chart.doughnut", "total value is 0");
     return "";
   }
   const cx = x + w / 2;
@@ -2627,11 +2675,11 @@ function renderDoughnutChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
-function renderScatterChart(chart, x, y, w, h) {
+function renderScatterChart(chart, x, y, w, h, context) {
   const parts = [];
   const { series } = chart;
   if (series.length === 0) {
-    debug("chart.scatter", "series is empty");
+    debugChart(context, "chart.scatter", "series is empty");
     return "";
   }
   let maxX = 0;
@@ -2665,11 +2713,11 @@ function renderScatterChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
-function renderBubbleChart(chart, x, y, w, h) {
+function renderBubbleChart(chart, x, y, w, h, context) {
   const parts = [];
   const { series } = chart;
   if (series.length === 0) {
-    debug("chart.bubble", "series is empty");
+    debugChart(context, "chart.bubble", "series is empty");
     return "";
   }
   let maxX = 0;
@@ -2713,21 +2761,21 @@ function renderBubbleChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
-function renderRadarChart(chart, x, y, w, h) {
+function renderRadarChart(chart, x, y, w, h, context) {
   const parts = [];
   const { series, categories } = chart;
   if (series.length === 0) {
-    debug("chart.radar", "series is empty");
+    debugChart(context, "chart.radar", "series is empty");
     return "";
   }
   const maxVal = getMaxValue(series);
   if (maxVal === 0) {
-    debug("chart.radar", "max value is 0");
+    debugChart(context, "chart.radar", "max value is 0");
     return "";
   }
   const catCount = categories.length || Math.max(...series.map((s) => s.values.length));
   if (catCount === 0) {
-    debug("chart.radar", "category count is 0");
+    debugChart(context, "chart.radar", "category count is 0");
     return "";
   }
   const cx = x + w / 2;
@@ -2790,11 +2838,15 @@ function renderRadarChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
-function renderStockChart(chart, x, y, w, h) {
+function renderStockChart(chart, x, y, w, h, context) {
   const parts = [];
   const { series, categories } = chart;
   if (series.length < 3) {
-    debug("chart.stock", `insufficient series count: ${series.length} (need at least 3)`);
+    debugChart(
+      context,
+      "chart.stock",
+      `insufficient series count: ${series.length} (need at least 3)`
+    );
     return "";
   }
   const highSeries = series[0];
@@ -2802,7 +2854,7 @@ function renderStockChart(chart, x, y, w, h) {
   const closeSeries = series[2];
   const catCount = categories.length || highSeries.values.length;
   if (catCount === 0) {
-    debug("chart.stock", "category count is 0");
+    debugChart(context, "chart.stock", "category count is 0");
     return "";
   }
   let maxVal = 0;
@@ -2814,7 +2866,7 @@ function renderStockChart(chart, x, y, w, h) {
     }
   }
   if (maxVal === minVal) {
-    debug("chart.stock", "max equals min value");
+    debugChart(context, "chart.stock", "max equals min value");
     return "";
   }
   const ticks = computeNiceTicks(minVal, maxVal);
@@ -2853,17 +2905,17 @@ function renderStockChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
-function renderSurfaceChart(chart, x, y, w, h) {
+function renderSurfaceChart(chart, x, y, w, h, context) {
   const parts = [];
   const { series, categories } = chart;
   if (series.length === 0) {
-    debug("chart.surface", "series is empty");
+    debugChart(context, "chart.surface", "series is empty");
     return "";
   }
   const rows = series.length;
   const cols = categories.length || Math.max(...series.map((s) => s.values.length));
   if (cols === 0) {
-    debug("chart.surface", "column count is 0");
+    debugChart(context, "chart.surface", "column count is 0");
     return "";
   }
   let minVal = Infinity;
@@ -2935,16 +2987,16 @@ function heatmapColor(t) {
   }
   return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
 }
-function renderOfPieChart(chart, x, y, w, h) {
+function renderOfPieChart(chart, x, y, w, h, context) {
   const parts = [];
   const series = chart.series[0];
   if (!series || series.values.length === 0) {
-    debug("chart.ofPie", "series is empty or has no values");
+    debugChart(context, "chart.ofPie", "series is empty or has no values");
     return "";
   }
   const total = series.values.reduce((sum, v) => sum + v, 0);
   if (total === 0) {
-    debug("chart.ofPie", "total value is 0");
+    debugChart(context, "chart.ofPie", "total value is 0");
     return "";
   }
   const splitPos = chart.splitPos ?? 2;
@@ -3045,40 +3097,40 @@ function renderOfPieChart(chart, x, y, w, h) {
 }
 function renderLegend(chart, chartW, chartH, position) {
   const parts = [];
-  const entries2 = chart.chartType === "pie" || chart.chartType === "doughnut" || chart.chartType === "ofPie" ? chart.categories.map((cat, i) => ({
+  const entries = chart.chartType === "pie" || chart.chartType === "doughnut" || chart.chartType === "ofPie" ? chart.categories.map((cat, i) => ({
     label: cat,
     color: getPieSliceColor(i, chart)
   })) : chart.series.map((s, i) => ({
     label: s.name ?? `Series ${i + 1}`,
     color: s.color
   }));
-  if (entries2.length === 0) return "";
+  if (entries.length === 0) return "";
   const ENTRY_HEIGHT = 20;
   if (position === "r" || position === "l") {
-    const totalH = entries2.length * ENTRY_HEIGHT;
+    const totalH = entries.length * ENTRY_HEIGHT;
     const startY = Math.max((chartH - totalH) / 2, 5);
     const legendX = position === "r" ? chartW - LEGEND_SIDE_WIDTH + 5 : 5;
-    for (let i = 0; i < entries2.length; i++) {
+    for (let i = 0; i < entries.length; i++) {
       const ey = startY + i * ENTRY_HEIGHT;
       parts.push(
-        `<rect x="${round2(legendX)}" y="${round2(ey)}" width="12" height="12" ${fillAttr(entries2[i].color)}/>`
+        `<rect x="${round2(legendX)}" y="${round2(ey)}" width="12" height="12" ${fillAttr(entries[i].color)}/>`
       );
       parts.push(
-        `<text x="${round2(legendX + 16)}" y="${round2(ey + 10)}" font-size="10" fill="#595959">${escapeXml(entries2[i].label)}</text>`
+        `<text x="${round2(legendX + 16)}" y="${round2(ey + 10)}" font-size="10" fill="#595959">${escapeXml(entries[i].label)}</text>`
       );
     }
   } else {
     const entryWidth = 80;
-    const totalWidth = entries2.length * entryWidth;
+    const totalWidth = entries.length * entryWidth;
     const startX = Math.max((chartW - totalWidth) / 2, 5);
     const legendY = position === "t" ? 25 : chartH - 15;
-    for (let i = 0; i < entries2.length; i++) {
+    for (let i = 0; i < entries.length; i++) {
       const ex = startX + i * entryWidth;
       parts.push(
-        `<rect x="${round2(ex)}" y="${round2(legendY - 6)}" width="12" height="12" ${fillAttr(entries2[i].color)}/>`
+        `<rect x="${round2(ex)}" y="${round2(legendY - 6)}" width="12" height="12" ${fillAttr(entries[i].color)}/>`
       );
       parts.push(
-        `<text x="${round2(ex + 16)}" y="${round2(legendY + 4)}" font-size="10" fill="#595959">${escapeXml(entries2[i].label)}</text>`
+        `<text x="${round2(ex + 16)}" y="${round2(legendY + 4)}" font-size="10" fill="#595959">${escapeXml(entries[i].label)}</text>`
       );
     }
   }
@@ -4424,8 +4476,6 @@ function renderCustomPath(path, shapeWidth, shapeHeight) {
 
 // ../renderer/src/renderer/text-renderer.ts
 init_font_metrics();
-init_font_mapping_context();
-init_text_path_context();
 
 // ../renderer/src/utils/text-wrap.ts
 var DEFAULT_FONT_SIZE = 18;
@@ -4477,7 +4527,7 @@ function splitTextIntoFragments(text) {
   }
   return fragments;
 }
-function tokenizeRuns(runs, defaultFontSize, fontScale) {
+function tokenizeRuns(runs, defaultFontSize, fontScale, textMeasurer, measurementContext) {
   const tokens = [];
   let isFirst = true;
   for (const run of runs) {
@@ -4503,12 +4553,13 @@ function tokenizeRuns(runs, defaultFontSize, fontScale) {
         const fontFamilyEa2 = run.properties.fontFamilyEa;
         const fragments2 = splitTextIntoFragments(part);
         for (const { fragment, breakable } of fragments2) {
-          const width = getTextMeasurer().measureTextWidth(
+          const width = textMeasurer.measureTextWidth(
             fragment,
             fontSize2,
             bold2,
             fontFamily2,
-            fontFamilyEa2
+            fontFamilyEa2,
+            measurementContext
           );
           tokens.push({
             text: fragment,
@@ -4527,12 +4578,13 @@ function tokenizeRuns(runs, defaultFontSize, fontScale) {
     const fontFamilyEa = run.properties.fontFamilyEa;
     const fragments = splitTextIntoFragments(run.text);
     for (const { fragment, breakable } of fragments) {
-      const width = getTextMeasurer().measureTextWidth(
+      const width = textMeasurer.measureTextWidth(
         fragment,
         fontSize,
         bold,
         fontFamily,
-        fontFamilyEa
+        fontFamilyEa,
+        measurementContext
       );
       tokens.push({
         text: fragment,
@@ -4551,7 +4603,7 @@ function isSpaceOnly(text) {
   }
   return true;
 }
-function splitTokenByChars(token, availableWidth, defaultFontSize, fontScale) {
+function splitTokenByChars(token, availableWidth, defaultFontSize, fontScale, textMeasurer, measurementContext) {
   const lines = [];
   let currentLine = [];
   let currentWidth = 0;
@@ -4560,12 +4612,13 @@ function splitTokenByChars(token, availableWidth, defaultFontSize, fontScale) {
   const fontFamily = token.properties.fontFamily;
   const fontFamilyEa = token.properties.fontFamilyEa;
   for (const char of token.text) {
-    const charWidth = getTextMeasurer().measureTextWidth(
+    const charWidth = textMeasurer.measureTextWidth(
       char,
       fontSize,
       bold,
       fontFamily,
-      fontFamilyEa
+      fontFamilyEa,
+      measurementContext
     );
     if (currentWidth + charWidth > availableWidth && currentLine.length > 0) {
       lines.push(currentLine);
@@ -4612,7 +4665,7 @@ function trimTrailingSpaces(segments) {
   }
   return segments;
 }
-function layoutTokensIntoLines(tokens, availableWidth, defaultFontSize, fontScale) {
+function layoutTokensIntoLines(tokens, availableWidth, defaultFontSize, fontScale, textMeasurer, measurementContext) {
   if (tokens.length === 0) return [{ segments: [] }];
   const lines = [];
   let currentLine = [];
@@ -4634,7 +4687,14 @@ function layoutTokensIntoLines(tokens, availableWidth, defaultFontSize, fontScal
       if (isSpaceOnly(token.text)) {
         continue;
       }
-      const splitLines = splitTokenByChars(token, availableWidth, defaultFontSize, fontScale);
+      const splitLines = splitTokenByChars(
+        token,
+        availableWidth,
+        defaultFontSize,
+        fontScale,
+        textMeasurer,
+        measurementContext
+      );
       for (let j = 0; j < splitLines.length; j++) {
         if (j < splitLines.length - 1) {
           const segments = trimTrailingSpaces(mergeSegments(splitLines[j]));
@@ -4667,14 +4727,27 @@ function layoutTokensIntoLines(tokens, availableWidth, defaultFontSize, fontScal
   }
   return lines.length > 0 ? lines : [{ segments: [] }];
 }
-function wrapParagraph(paragraph, availableWidth, defaultFontSize = DEFAULT_FONT_SIZE, fontScale = 1) {
+function wrapParagraph(paragraph, availableWidth, defaultFontSize = DEFAULT_FONT_SIZE, fontScale = 1, textMeasurer = getTextMeasurer(), measurementContext) {
   if (paragraph.runs.length === 0 || !paragraph.runs.some((r) => r.text.length > 0)) {
     return [{ segments: [] }];
   }
   const safeWidth = Math.max(availableWidth, 1);
-  const tokens = tokenizeRuns(paragraph.runs, defaultFontSize, fontScale);
+  const tokens = tokenizeRuns(
+    paragraph.runs,
+    defaultFontSize,
+    fontScale,
+    textMeasurer,
+    measurementContext
+  );
   if (tokens.length === 0) return [{ segments: [] }];
-  return layoutTokensIntoLines(tokens, safeWidth, defaultFontSize, fontScale);
+  return layoutTokensIntoLines(
+    tokens,
+    safeWidth,
+    defaultFontSize,
+    fontScale,
+    textMeasurer,
+    measurementContext
+  );
 }
 
 // ../renderer/src/utils/unit-types.ts
@@ -4727,10 +4800,10 @@ function resolveTextDimensions(bodyProperties, originalWidth, originalHeight) {
     marginBottomPx: emuToPixels(bodyProperties.marginBottom)
   };
 }
-function renderTextBody(textBody, transform) {
-  const fontResolver = getTextPathFontResolver();
+function renderTextBody(textBody, transform, context = createLegacyRendererContext()) {
+  const fontResolver = context.textPathFontResolver;
   if (fontResolver) {
-    return renderTextBodyAsPath(textBody, transform, fontResolver);
+    return renderTextBodyAsPath(textBody, transform, fontResolver, context);
   }
   const { bodyProperties, paragraphs } = textBody;
   const originalWidth = emuToPixels(transform.extentWidth);
@@ -4753,12 +4826,13 @@ function renderTextBody(textBody, transform) {
       fontScale,
       lnSpcReduction,
       textWidth,
-      availableHeight
+      availableHeight,
+      context
     );
   }
   const scaledDefaultFontSizePt = defaultFontSize * fontScale;
-  const defaultLineHeightRatio = getDefaultLineHeightRatio(paragraphs);
-  const defaultAscenderRatio = getDefaultAscenderRatio(paragraphs);
+  const defaultLineHeightRatio = getDefaultLineHeightRatio(paragraphs, context);
+  const defaultAscenderRatio = getDefaultAscenderRatio(paragraphs, context);
   const defaultNaturalHeightPt = scaledDefaultFontSizePt * defaultLineHeightRatio;
   const tspans = [];
   let isFirstLine = true;
@@ -4798,7 +4872,9 @@ function renderTextBody(textBody, transform) {
         para,
         effectiveTextWidth,
         scaledDefaultFontSizePt,
-        fontScale
+        fontScale,
+        context.textMeasurer,
+        context
       );
       for (let lineIdx = 0; lineIdx < wrappedLines.length; lineIdx++) {
         const line = wrappedLines[lineIdx];
@@ -4818,7 +4894,8 @@ function renderTextBody(textBody, transform) {
           const lineNaturalHeightPt = computeLineNaturalHeight(
             line.segments,
             defaultFontSize,
-            fontScale
+            fontScale,
+            context
           );
           const dy = computeDy(
             isFirstLine,
@@ -4835,16 +4912,17 @@ function renderTextBody(textBody, transform) {
             para.properties,
             lineFontSize,
             fontScale,
-            bulletFontChain
+            bulletFontChain,
+            context
           );
-          getFontUsageCollector()?.record(bulletFontChain, bulletText);
+          context.fontUsageCollector?.record(bulletFontChain, bulletText);
           tspans.push(
             `<tspan x="${bulletX}" dy="${dy}" text-anchor="start" ${bulletStyles}>${escapeXml2(bulletText)}</tspan>`
           );
           for (let segIdx = 0; segIdx < line.segments.length; segIdx++) {
             const seg = line.segments[segIdx];
             const prefix = segIdx === 0 ? `x="${xPos}" text-anchor="${anchorValue}" ` : "";
-            tspans.push(renderSegment(seg.text, seg.properties, fontScale, prefix));
+            tspans.push(renderSegment(seg.text, seg.properties, fontScale, prefix, context));
           }
         } else {
           for (let segIdx = 0; segIdx < line.segments.length; segIdx++) {
@@ -4853,7 +4931,8 @@ function renderTextBody(textBody, transform) {
               const lineNaturalHeightPt = computeLineNaturalHeight(
                 line.segments,
                 defaultFontSize,
-                fontScale
+                fontScale,
+                context
               );
               const dy = computeDy(
                 isFirstLine,
@@ -4861,9 +4940,9 @@ function renderTextBody(textBody, transform) {
                 lineGapPx
               );
               const prefix = `x="${xPos}" dy="${dy}" text-anchor="${anchorValue}" `;
-              tspans.push(renderSegment(seg.text, seg.properties, fontScale, prefix));
+              tspans.push(renderSegment(seg.text, seg.properties, fontScale, prefix, context));
             } else {
-              tspans.push(renderSegment(seg.text, seg.properties, fontScale, ""));
+              tspans.push(renderSegment(seg.text, seg.properties, fontScale, "", context));
             }
           }
         }
@@ -4874,7 +4953,12 @@ function renderTextBody(textBody, transform) {
       if (bulletText) {
         const firstRun = para.runs.find((r) => r.text.length > 0);
         const fontSize = (firstRun?.properties.fontSize ?? defaultFontSize) * fontScale;
-        const naturalHeightPt = computeLineNaturalHeight(para.runs, defaultFontSize, fontScale);
+        const naturalHeightPt = computeLineNaturalHeight(
+          para.runs,
+          defaultFontSize,
+          fontScale,
+          context
+        );
         const dy = computeDy(
           isFirstLine,
           getLineHeightPx(para, naturalHeightPt, lnSpcReduction),
@@ -4889,9 +4973,10 @@ function renderTextBody(textBody, transform) {
           para.properties,
           fontSize,
           fontScale,
-          bulletFontChain
+          bulletFontChain,
+          context
         );
-        getFontUsageCollector()?.record(bulletFontChain, bulletText);
+        context.fontUsageCollector?.record(bulletFontChain, bulletText);
         tspans.push(
           `<tspan x="${bulletX}" dy="${dy}" text-anchor="start" ${bulletStyles}>${escapeXml2(bulletText)}</tspan>`
         );
@@ -4902,20 +4987,25 @@ function renderTextBody(textBody, transform) {
         if (!firstRunRendered) {
           if (bulletText) {
             const prefix = `x="${xPos}" text-anchor="${anchorValue}" `;
-            tspans.push(renderSegment(run.text, run.properties, fontScale, prefix));
+            tspans.push(renderSegment(run.text, run.properties, fontScale, prefix, context));
           } else {
-            const naturalHeightPt = computeLineNaturalHeight(para.runs, defaultFontSize, fontScale);
+            const naturalHeightPt = computeLineNaturalHeight(
+              para.runs,
+              defaultFontSize,
+              fontScale,
+              context
+            );
             const dy = computeDy(
               isFirstLine,
               getLineHeightPx(para, naturalHeightPt, lnSpcReduction),
               paragraphGapPx
             );
             const prefix = `x="${xPos}" dy="${dy}" text-anchor="${anchorValue}" `;
-            tspans.push(renderSegment(run.text, run.properties, fontScale, prefix));
+            tspans.push(renderSegment(run.text, run.properties, fontScale, prefix, context));
           }
           firstRunRendered = true;
         } else {
-          tspans.push(renderSegment(run.text, run.properties, fontScale, ""));
+          tspans.push(renderSegment(run.text, run.properties, fontScale, "", context));
         }
       }
       isFirstLine = false;
@@ -4929,7 +5019,8 @@ function renderTextBody(textBody, transform) {
     shouldWrap,
     textWidth,
     lnSpcReduction,
-    fontScale
+    fontScale,
+    context
   );
   if (bodyProperties.anchor === "ctr") {
     yStart = Math.max(marginTopPx, (height - totalTextHeight) / 2);
@@ -5026,13 +5117,13 @@ function toAlpha(num) {
 function buildBulletFontChain(props, runFontFamily, runFontFamilyEa) {
   return [props.bulletFont, runFontFamily ?? null, runFontFamilyEa ?? null];
 }
-function buildBulletStyleAttrs(props, textFontSizePt, fontScale, bulletFontChain) {
+function buildBulletStyleAttrs(props, textFontSizePt, fontScale, bulletFontChain, context = createLegacyRendererContext()) {
   const styles = [];
   if (props.bulletSizePct !== null) {
     const size = textFontSizePt * (props.bulletSizePct / 1e5);
     styles.push(`font-size="${size}pt"`);
   }
-  const fontFamilyValue = buildFontFamilyValue(bulletFontChain);
+  const fontFamilyValue = buildFontFamilyValue(bulletFontChain, context);
   if (fontFamilyValue) {
     styles.push(`font-family="${fontFamilyValue}"`);
   }
@@ -5085,13 +5176,14 @@ function getLineFontSize(segments, defaultFontSize) {
   }
   return defaultFontSize;
 }
-function computeLineNaturalHeight(segments, defaultFontSize, fontScale) {
+function computeLineNaturalHeight(segments, defaultFontSize, fontScale, context = createLegacyRendererContext()) {
   let maxHeight = 0;
   for (const seg of segments) {
     const fontSize = (seg.properties.fontSize ?? defaultFontSize) * fontScale;
-    const ratio = getTextMeasurer().getLineHeightRatio(
+    const ratio = context.textMeasurer.getLineHeightRatio(
       seg.properties.fontFamily,
-      seg.properties.fontFamilyEa
+      seg.properties.fontFamilyEa,
+      context
     );
     maxHeight = Math.max(maxHeight, fontSize * ratio);
   }
@@ -5132,14 +5224,14 @@ function getGenericFamily(fontFamily) {
 function escapeFontName(name) {
   return name.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function buildFontFamilyValue(fonts) {
+function buildFontFamilyValue(fonts, context = createLegacyRendererContext()) {
   const uniqueFonts = [];
   const seen = /* @__PURE__ */ new Set();
   for (const font of fonts) {
     if (font && !seen.has(font)) {
       seen.add(font);
       uniqueFonts.push(font);
-      const mapped = getCurrentMappedFont(font);
+      const mapped = getMappedFontFromContext(font, context);
       if (mapped && !seen.has(mapped)) {
         seen.add(mapped);
         uniqueFonts.push(mapped);
@@ -5160,14 +5252,14 @@ function buildFontFamilyValue(fonts) {
   parts.push(genericFamily);
   return parts.join(", ");
 }
-function buildStyleAttrs(props, fontScale = 1, fontFamilies) {
+function buildStyleAttrs(props, fontScale = 1, fontFamilies, context = createLegacyRendererContext()) {
   const styles = [];
   if (props.fontSize) {
     const scaledSize = props.fontSize * fontScale;
     styles.push(`font-size="${scaledSize}pt"`);
   }
   const fonts = fontFamilies ?? [props.fontFamily, props.fontFamilyEa];
-  const fontFamilyValue = buildFontFamilyValue(fonts);
+  const fontFamilyValue = buildFontFamilyValue(fonts, context);
   if (fontFamilyValue) {
     styles.push(`font-family="${fontFamilyValue}"`);
   }
@@ -5205,20 +5297,20 @@ function buildStyleAttrs(props, fontScale = 1, fontFamilies) {
   }
   return styles.join(" ");
 }
-function renderSegment(text, props, fontScale, prefix) {
+function renderSegment(text, props, fontScale, prefix, context) {
   let tspanContent;
   if (!needsScriptSplit(props)) {
-    const styles = buildStyleAttrs(props, fontScale);
-    getFontUsageCollector()?.record([props.fontFamily, props.fontFamilyEa], text);
+    const styles = buildStyleAttrs(props, fontScale, void 0, context);
+    context.fontUsageCollector?.record([props.fontFamily, props.fontFamilyEa], text);
     tspanContent = `<tspan ${prefix}${styles}>${escapeXml2(text)}</tspan>`;
   } else {
     const parts = splitByScript(text);
     const result = [];
     for (let i = 0; i < parts.length; i++) {
       const part = parts[i];
-      const fonts = part.isEa ? [props.fontFamilyEa, getJpanFallbackFont(), props.fontFamily] : [props.fontFamily, props.fontFamilyEa];
-      const styles = buildStyleAttrs(props, fontScale, fonts);
-      getFontUsageCollector()?.record(fonts, part.text);
+      const fonts = part.isEa ? [props.fontFamilyEa, getJpanFallbackFontFromContext(context), props.fontFamily] : [props.fontFamily, props.fontFamilyEa];
+      const styles = buildStyleAttrs(props, fontScale, fonts, context);
+      context.fontUsageCollector?.record(fonts, part.text);
       if (i === 0) {
         result.push(`<tspan ${prefix}${styles}>${escapeXml2(part.text)}</tspan>`);
       } else {
@@ -5241,33 +5333,35 @@ function getDefaultFontSize(paragraphs) {
   }
   return DEFAULT_FONT_SIZE_PT;
 }
-function getDefaultLineHeightRatio(paragraphs) {
+function getDefaultLineHeightRatio(paragraphs, context = createLegacyRendererContext()) {
   for (const p of paragraphs) {
     for (const r of p.runs) {
       if (r.properties.fontFamily || r.properties.fontFamilyEa) {
-        return getTextMeasurer().getLineHeightRatio(
+        return context.textMeasurer.getLineHeightRatio(
           r.properties.fontFamily,
-          r.properties.fontFamilyEa
+          r.properties.fontFamilyEa,
+          context
         );
       }
     }
   }
   return 1.2;
 }
-function getDefaultAscenderRatio(paragraphs) {
+function getDefaultAscenderRatio(paragraphs, context = createLegacyRendererContext()) {
   for (const p of paragraphs) {
     for (const r of p.runs) {
       if (r.properties.fontFamily || r.properties.fontFamilyEa) {
-        return getTextMeasurer().getAscenderRatio(
+        return context.textMeasurer.getAscenderRatio(
           r.properties.fontFamily,
-          r.properties.fontFamilyEa
+          r.properties.fontFamilyEa,
+          context
         );
       }
     }
   }
   return 1;
 }
-function computeSpAutofitHeight(textBody, transform) {
+function computeSpAutofitHeight(textBody, transform, context = createLegacyRendererContext()) {
   const { bodyProperties, paragraphs } = textBody;
   const hasText = paragraphs.some((p) => p.runs.some((r) => r.text.length > 0));
   if (!hasText) return null;
@@ -5279,13 +5373,21 @@ function computeSpAutofitHeight(textBody, transform) {
   const textWidth = numCol > 1 ? fullTextWidth / numCol : fullTextWidth;
   const defaultFontSize = getDefaultFontSize(paragraphs);
   const shouldWrap = bodyProperties.wrap !== "none";
-  const textHeight = estimateTextHeight(paragraphs, defaultFontSize, shouldWrap, textWidth);
+  const textHeight = estimateTextHeight(
+    paragraphs,
+    defaultFontSize,
+    shouldWrap,
+    textWidth,
+    void 0,
+    void 0,
+    context
+  );
   const requiredHeightPx = textHeight + marginTopPx + marginBottomPx;
   if (requiredHeightPx <= height) return null;
   const DEFAULT_DPI2 = 96;
   return asEmu(requiredHeightPx / DEFAULT_DPI2 * EMU_PER_INCH);
 }
-function computeShrinkToFitScale(paragraphs, defaultFontSize, fontScale, lnSpcReduction, textWidth, availableHeight) {
+function computeShrinkToFitScale(paragraphs, defaultFontSize, fontScale, lnSpcReduction, textWidth, availableHeight, context = createLegacyRendererContext()) {
   if (availableHeight <= 0) return fontScale;
   const minScale = fontScale * 0.1;
   let scale = fontScale;
@@ -5297,7 +5399,8 @@ function computeShrinkToFitScale(paragraphs, defaultFontSize, fontScale, lnSpcRe
       true,
       textWidth,
       lnSpcReduction,
-      scale
+      scale,
+      context
     );
     if (textHeight <= availableHeight) break;
     const newScale = scale * (availableHeight / textHeight);
@@ -5306,15 +5409,15 @@ function computeShrinkToFitScale(paragraphs, defaultFontSize, fontScale, lnSpcRe
   }
   return scale;
 }
-function estimateTextHeight(paragraphs, defaultFontSize, shouldWrap, textWidth, lnSpcReduction = 0, fontScale = 1) {
+function estimateTextHeight(paragraphs, defaultFontSize, shouldWrap, textWidth, lnSpcReduction = 0, fontScale = 1, context = createLegacyRendererContext()) {
   let totalHeight = 0;
-  const defaultRatio = getDefaultLineHeightRatio(paragraphs);
+  const defaultRatio = getDefaultLineHeightRatio(paragraphs, context);
   let prevSpaceAfterPx = 0;
   const scaledDefaultForWrap = defaultFontSize * fontScale;
   for (let pIdx = 0; pIdx < paragraphs.length; pIdx++) {
     const para = paragraphs[pIdx];
     const isEmpty = !para.runs.some((r) => r.text.length > 0);
-    const naturalHeightPt = isEmpty && para.endParaRunProperties?.fontSize ? para.endParaRunProperties.fontSize * fontScale * defaultRatio : computeLineNaturalHeight(para.runs, defaultFontSize, fontScale);
+    const naturalHeightPt = isEmpty && para.endParaRunProperties?.fontSize ? para.endParaRunProperties.fontSize * fontScale * defaultRatio : computeLineNaturalHeight(para.runs, defaultFontSize, fontScale, context);
     const lineHeight = getLineHeightPx(
       para,
       naturalHeightPt > 0 ? naturalHeightPt : defaultFontSize * fontScale * defaultRatio,
@@ -5322,7 +5425,14 @@ function estimateTextHeight(paragraphs, defaultFontSize, shouldWrap, textWidth,
     );
     let lineCount;
     if (shouldWrap && para.runs.length > 0 && para.runs.some((r) => r.text.length > 0)) {
-      const wrappedLines = wrapParagraph(para, textWidth, scaledDefaultForWrap, fontScale);
+      const wrappedLines = wrapParagraph(
+        para,
+        textWidth,
+        scaledDefaultForWrap,
+        fontScale,
+        context.textMeasurer,
+        context
+      );
       lineCount = wrappedLines.length;
     } else {
       lineCount = para.runs.some((r) => r.text.length > 0) ? 1 : 1;
@@ -5343,9 +5453,9 @@ function computePathLineX(alignment, textStartX, effectiveTextWidth, width, marg
   if (alignment === "r") return width - marginRightPx - lineWidth;
   return textStartX;
 }
-function measureLineWidth(segments, defaultFontSize, fontScale, fontResolver) {
+function measureLineWidth(segments, defaultFontSize, fontScale, fontResolver, context = createLegacyRendererContext()) {
   let totalWidth = 0;
-  const jpanFallback = fontResolver ? getJpanFallbackFont() : null;
+  const jpanFallback = fontResolver ? getJpanFallbackFontFromContext(context) : null;
   for (const seg of segments) {
     const fontSize = (seg.properties.fontSize ?? defaultFontSize) * fontScale;
     if (fontResolver) {
@@ -5353,19 +5463,21 @@ function measureLineWidth(segments, defaultFontSize, fontScale, fontResolver) {
       const font = fontResolver.resolveFont(
         seg.properties.fontFamily,
         seg.properties.fontFamilyEa,
-        jpanFallback
+        jpanFallback,
+        context
       );
       if (font) {
         totalWidth += font.getAdvanceWidth(seg.text, fontSizePx);
         continue;
       }
     }
-    totalWidth += getTextMeasurer().measureTextWidth(
+    totalWidth += context.textMeasurer.measureTextWidth(
       seg.text,
       fontSize,
       seg.properties.bold,
       seg.properties.fontFamily,
-      seg.properties.fontFamilyEa
+      seg.properties.fontFamilyEa,
+      context
     );
   }
   return totalWidth;
@@ -5401,7 +5513,7 @@ function renderTextDecorations(x, y, segmentWidth, fontSizePx, props) {
   }
   return lines;
 }
-function renderSegmentAsPath(text, props, x, y, fontScale, defaultFontSize, fontResolver, vert) {
+function renderSegmentAsPath(text, props, x, y, fontScale, defaultFontSize, fontResolver, context, vert) {
   const fontSize = (props.fontSize ?? defaultFontSize) * fontScale;
   const fontSizePx = fontSize * PX_PER_PT3;
   const parts = [];
@@ -5411,16 +5523,17 @@ function renderSegmentAsPath(text, props, x, y, fontScale, defaultFontSize, font
   if (props.baseline > 0) yOffset = -fontSizePx * 0.35;
   else if (props.baseline < 0) yOffset = fontSizePx * 0.2;
   const effectiveY = y + yOffset;
-  const jpanFallback = getJpanFallbackFont();
+  const jpanFallback = getJpanFallbackFontFromContext(context);
   const processSegment = (segText, fontFamily, fontFamilyEa) => {
     if (segText.length === 0) return;
-    const font = fontResolver.resolveFont(fontFamily, fontFamilyEa, jpanFallback);
-    const segWidth = font ? font.getAdvanceWidth(segText, fontSizePx) : getTextMeasurer().measureTextWidth(
+    const font = fontResolver.resolveFont(fontFamily, fontFamilyEa, jpanFallback, context);
+    const segWidth = font ? font.getAdvanceWidth(segText, fontSizePx) : context.textMeasurer.measureTextWidth(
       segText,
       fontSize,
       props.bold,
       props.fontFamily,
-      props.fontFamilyEa
+      props.fontFamilyEa,
+      context
     );
     if (font) {
       const path = font.getPath(segText, x + totalWidth, effectiveY, fontSizePx);
@@ -5437,15 +5550,16 @@ function renderSegmentAsPath(text, props, x, y, fontScale, defaultFontSize, font
   };
   const processCjkUpright = (segText, fontFamily, fontFamilyEa) => {
     if (segText.length === 0) return;
-    const font = fontResolver.resolveFont(fontFamily, fontFamilyEa, jpanFallback);
+    const font = fontResolver.resolveFont(fontFamily, fontFamilyEa, jpanFallback, context);
     const fillAttrs = buildPathFillAttrs(props);
     for (const char of segText) {
-      const charWidth = font ? font.getAdvanceWidth(char, fontSizePx) : getTextMeasurer().measureTextWidth(
+      const charWidth = font ? font.getAdvanceWidth(char, fontSizePx) : context.textMeasurer.measureTextWidth(
         char,
         fontSize,
         props.bold,
         props.fontFamily,
-        props.fontFamilyEa
+        props.fontFamilyEa,
+        context
       );
       if (font) {
         const charX = x + totalWidth;
@@ -5495,13 +5609,13 @@ function renderSegmentAsPath(text, props, x, y, fontScale, defaultFontSize, font
   }
   return { svg, width: totalWidth };
 }
-function renderBulletAsPath(bulletText, x, y, paraProps, textFontSizePt, fontScale, fontResolver, runFontFamily, runFontFamilyEa) {
+function renderBulletAsPath(bulletText, x, y, paraProps, textFontSizePt, fontScale, fontResolver, context, runFontFamily, runFontFamilyEa) {
   let bulletFontSize = textFontSizePt;
   if (paraProps.bulletSizePct !== null) {
     bulletFontSize = textFontSizePt * (paraProps.bulletSizePct / 1e5);
   }
   const fontSizePx = bulletFontSize * PX_PER_PT3;
-  const font = paraProps.bulletFont ? fontResolver.resolveFont(paraProps.bulletFont, null) : fontResolver.resolveFont(runFontFamily ?? null, runFontFamilyEa ?? null);
+  const font = paraProps.bulletFont ? fontResolver.resolveFont(paraProps.bulletFont, null, void 0, context) : fontResolver.resolveFont(runFontFamily ?? null, runFontFamilyEa ?? null, void 0, context);
   if (!font) return [];
   const path = font.getPath(bulletText, x, y, fontSizePx);
   const pathData = path.toPathData(2);
@@ -5517,7 +5631,7 @@ function renderBulletAsPath(bulletText, x, y, paraProps, textFontSizePt, fontSca
   }
   return [`<path d="${pathData}" ${attrs.join(" ")}/>`];
 }
-function renderTextBodyAsPath(textBody, transform, fontResolver) {
+function renderTextBodyAsPath(textBody, transform, fontResolver, context) {
   const { bodyProperties, paragraphs } = textBody;
   const originalWidth = emuToPixels(transform.extentWidth);
   const originalHeight = emuToPixels(transform.extentHeight);
@@ -5539,12 +5653,13 @@ function renderTextBodyAsPath(textBody, transform, fontResolver) {
       fontScale,
       lnSpcReduction,
       textWidth,
-      availableHeight
+      availableHeight,
+      context
     );
   }
   const scaledDefaultFontSizePt = defaultFontSize * fontScale;
-  const defaultLineHeightRatio = getDefaultLineHeightRatio(paragraphs);
-  const defaultAscenderRatio = getDefaultAscenderRatio(paragraphs);
+  const defaultLineHeightRatio = getDefaultLineHeightRatio(paragraphs, context);
+  const defaultAscenderRatio = getDefaultAscenderRatio(paragraphs, context);
   const defaultNaturalHeightPt = scaledDefaultFontSizePt * defaultLineHeightRatio;
   let yStart = marginTopPx;
   const totalTextHeight = estimateTextHeight(
@@ -5553,7 +5668,8 @@ function renderTextBodyAsPath(textBody, transform, fontResolver) {
     shouldWrap,
     textWidth,
     lnSpcReduction,
-    fontScale
+    fontScale,
+    context
   );
   if (bodyProperties.anchor === "ctr") {
     yStart = Math.max(marginTopPx, (height - totalTextHeight) / 2);
@@ -5592,7 +5708,9 @@ function renderTextBodyAsPath(textBody, transform, fontResolver) {
         para,
         effectiveTextWidth,
         scaledDefaultFontSizePt,
-        fontScale
+        fontScale,
+        context.textMeasurer,
+        context
       );
       for (let lineIdx = 0; lineIdx < wrappedLines.length; lineIdx++) {
         const line = wrappedLines[lineIdx];
@@ -5607,12 +5725,19 @@ function renderTextBodyAsPath(textBody, transform, fontResolver) {
         const lineNaturalHeightPt = computeLineNaturalHeight(
           line.segments,
           defaultFontSize,
-          fontScale
+          fontScale,
+          context
         );
         if (!isFirstLine) {
           currentY += getLineHeightPx(para, lineNaturalHeightPt, lnSpcReduction) + lineGapPx;
         }
-        const lineWidth = measureLineWidth(line.segments, defaultFontSize, fontScale, fontResolver);
+        const lineWidth = measureLineWidth(
+          line.segments,
+          defaultFontSize,
+          fontScale,
+          fontResolver,
+          context
+        );
         const lineStartX = computePathLineX(
           para.properties.alignment,
           textStartX,
@@ -5634,6 +5759,7 @@ function renderTextBodyAsPath(textBody, transform, fontResolver) {
               lineFontSize,
               fontScale,
               fontResolver,
+              context,
               firstSeg?.properties.fontFamily,
               firstSeg?.properties.fontFamilyEa
             )
@@ -5648,6 +5774,7 @@ function renderTextBodyAsPath(textBody, transform, fontResolver) {
             fontScale,
             defaultFontSize,
             fontResolver,
+            context,
             bodyProperties.vert
           );
           if (result.svg) elements.push(result.svg);
@@ -5656,12 +5783,23 @@ function renderTextBodyAsPath(textBody, transform, fontResolver) {
         isFirstLine = false;
       }
     } else {
-      const naturalHeightPt = computeLineNaturalHeight(para.runs, defaultFontSize, fontScale);
+      const naturalHeightPt = computeLineNaturalHeight(
+        para.runs,
+        defaultFontSize,
+        fontScale,
+        context
+      );
       if (!isFirstLine) {
         currentY += getLineHeightPx(para, naturalHeightPt, lnSpcReduction) + paragraphGapPx;
       }
       const runsAsSegments = para.runs.filter((r) => r.text.length > 0).map((r) => ({ text: r.text, properties: r.properties }));
-      const lineWidth = measureLineWidth(runsAsSegments, defaultFontSize, fontScale, fontResolver);
+      const lineWidth = measureLineWidth(
+        runsAsSegments,
+        defaultFontSize,
+        fontScale,
+        fontResolver,
+        context
+      );
       const lineStartX = computePathLineX(
         para.properties.alignment,
         textStartX,
@@ -5683,6 +5821,7 @@ function renderTextBodyAsPath(textBody, transform, fontResolver) {
             fontSize,
             fontScale,
             fontResolver,
+            context,
             firstRun?.properties.fontFamily,
             firstRun?.properties.fontFamilyEa
           )
@@ -5698,6 +5837,7 @@ function renderTextBodyAsPath(textBody, transform, fontResolver) {
           fontScale,
           defaultFontSize,
           fontResolver,
+          context,
           bodyProperties.vert
         );
         if (result.svg) elements.push(result.svg);
@@ -5723,11 +5863,11 @@ function escapeXml2(str) {
 }
 
 // ../renderer/src/renderer/shape-renderer.ts
-function renderShape(shape) {
+function renderShape(shape, context = createLegacyRendererContext()) {
   const { transform, geometry, fill, outline, textBody, effects } = shape;
   let effectiveTransform = transform;
   if (textBody?.bodyProperties.autoFit === "spAutofit") {
-    const requiredHeightEmu = computeSpAutofitHeight(textBody, transform);
+    const requiredHeightEmu = computeSpAutofitHeight(textBody, transform, context);
     if (requiredHeightEmu !== null) {
       effectiveTransform = { ...transform, extentHeight: requiredHeightEmu };
     }
@@ -5754,7 +5894,7 @@ function renderShape(shape) {
     parts.push(styledGeometry);
   }
   if (textBody) {
-    const textSvg = renderTextBody(textBody, effectiveTransform);
+    const textSvg = renderTextBody(textBody, effectiveTransform, context);
     if (textSvg) {
       parts.push(textSvg);
     }
@@ -5794,7 +5934,7 @@ function renderConnector(connector) {
 }
 
 // ../renderer/src/renderer/table-renderer.ts
-function renderTable(element) {
+function renderTable(element, context = createLegacyRendererContext()) {
   const { transform, table } = element;
   const transformAttr = buildTransformAttr(transform);
   const colWidths = table.columns.map((col) => emuToPixels(col.width));
@@ -5857,7 +5997,7 @@ function renderTable(element) {
           flipH: false,
           flipV: false
         };
-        const textSvg = renderTextBody(cell.textBody, cellTransform);
+        const textSvg = renderTextBody(cell.textBody, cellTransform, context);
         if (textSvg) {
           parts.push(`<g transform="translate(${x}, ${y})">${textSvg}</g>`);
         }
@@ -5882,7 +6022,7 @@ function pixelsToEmu(px) {
 }
 
 // ../renderer/src/renderer/svg-renderer.ts
-function renderSlideToSvg(slide, slideSize) {
+function renderSlideToSvg(slide, slideSize, context = createLegacyRendererContext()) {
   const width = emuToPixels(slideSize.width);
   const height = emuToPixels(slideSize.height);
   const parts = [];
@@ -5903,7 +6043,7 @@ function renderSlideToSvg(slide, slideSize) {
     parts.push(`<rect width="${width}" height="${height}" fill="#FFFFFF"/>`);
   }
   for (const element of slide.elements) {
-    const result = renderElement(element);
+    const result = renderElement(element, context);
     if (result) {
       parts.push(result.content);
       defs.push(...result.defs);
@@ -5915,11 +6055,11 @@ function renderSlideToSvg(slide, slideSize) {
   parts.push("</svg>");
   return parts.join("");
 }
-function renderElement(element) {
+function renderElement(element, context) {
   let result = null;
   switch (element.type) {
     case "shape":
-      result = renderShape(element);
+      result = renderShape(element, context);
       break;
     case "image":
       result = renderImage(element);
@@ -5928,13 +6068,13 @@ function renderElement(element) {
       result = renderConnector(element);
       break;
     case "group":
-      result = renderGroup(element);
+      result = renderGroup(element, context);
       break;
     case "chart":
-      result = renderChart(element);
+      result = renderChart(element, context);
       break;
     case "table":
-      result = renderTable(element);
+      result = renderTable(element, context);
       break;
   }
   if (result && "altText" in element && element.altText) {
@@ -5950,7 +6090,7 @@ function addAriaLabel(svgFragment, altText) {
   const escaped = altText.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
   return svgFragment.replace(/^<(g|image|path)\b/, `<$1 role="img" aria-label="${escaped}"`);
 }
-function renderGroup(group) {
+function renderGroup(group, context) {
   const x = emuToPixels(group.transform.offsetX);
   const y = emuToPixels(group.transform.offsetY);
   const w = emuToPixels(group.transform.extentWidth);
@@ -5980,7 +6120,7 @@ function renderGroup(group) {
   const defs = [];
   parts.push(`<g transform="${transformParts.join(" ")}">`);
   for (const child of group.children) {
-    const childResult = renderElement(child);
+    const childResult = renderElement(child, context);
     if (childResult) {
       parts.push(childResult.content);
       defs.push(...childResult.defs);
@@ -6020,6 +6160,58 @@ function asSourceNodeId(value) {
 function asRawSidecarId(value) {
   return unsafeBrandAssertion2(value);
 }
+var RELS_SUFFIX = ".rels";
+var RELS_MARKER = "_rels/";
+var ABSOLUTE_URI_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+function isRelationshipPart(path) {
+  return path.endsWith(RELS_SUFFIX) && path.includes(RELS_MARKER);
+}
+function relationshipsSourcePartPath(relsPath) {
+  const idx = relsPath.lastIndexOf(RELS_MARKER);
+  const dir = relsPath.slice(0, idx);
+  const file = relsPath.slice(idx + RELS_MARKER.length);
+  const base = file.endsWith(RELS_SUFFIX) ? file.slice(0, -RELS_SUFFIX.length) : file;
+  return asPartPath(dir + base);
+}
+function resolveRelationshipTarget(sourcePartPath, target) {
+  if (ABSOLUTE_URI_PATTERN.test(target)) return target;
+  const combined = target.startsWith("/") ? target.slice(1) : joinPackageRelativeTarget(sourcePartPath, target);
+  return normalizePackagePath(combined);
+}
+function resolveInternalRelationshipTarget(sourcePartPath, relationship) {
+  if (relationship.targetMode === "External") return void 0;
+  return asPartPath(resolveRelationshipTarget(sourcePartPath, relationship.target));
+}
+function parseRelationshipTargetMode(value) {
+  if (value === "Internal" || value === "External") return value;
+  return void 0;
+}
+function joinPackageRelativeTarget(sourcePartPath, target) {
+  const slash = sourcePartPath.lastIndexOf("/");
+  const baseDir = slash === -1 ? "" : sourcePartPath.slice(0, slash);
+  return baseDir === "" ? target : `${baseDir}/${target}`;
+}
+function normalizePackagePath(path) {
+  const segments = [];
+  for (const segment of path.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments.join("/");
+}
+var EDITABLE_TEXT_RUN_PROPERTIES = [
+  "bold",
+  "italic",
+  "underline",
+  "fontSize",
+  "color",
+  "typeface"
+];
+var EDITABLE_TEXT_RUN_PROPERTY_SET = new Set(EDITABLE_TEXT_RUN_PROPERTIES);
 function asEmu2(value) {
   return unsafeBrandAssertion2(value);
 }
@@ -6629,14 +6821,14 @@ function parseLineJoin(ln) {
 }
 function parseArrowEndpoint(node) {
   if (!node) return void 0;
-  const type = parseEnumValue(getAttr(node, "type"), ARROW_TYPES);
+  const type = parseEnumValue(getAttr(node, "type"), ARROW_TYPES2);
   if (type === void 0) return void 0;
   const width = getAttr(node, "w") ?? "med";
   const length = getAttr(node, "len") ?? "med";
   return {
     type,
-    width: parseEnumValueWithDefault(width, ARROW_SIZES, "med"),
-    length: parseEnumValueWithDefault(length, ARROW_SIZES, "med")
+    width: parseEnumValueWithDefault(width, ARROW_SIZES2, "med"),
+    length: parseEnumValueWithDefault(length, ARROW_SIZES2, "med")
   };
 }
 var DASH_STYLES = /* @__PURE__ */ new Set([
@@ -6649,14 +6841,14 @@ var DASH_STYLES = /* @__PURE__ */ new Set([
   "sysDash",
   "sysDot"
 ]);
-var ARROW_TYPES = /* @__PURE__ */ new Set([
+var ARROW_TYPES2 = /* @__PURE__ */ new Set([
   "triangle",
   "stealth",
   "diamond",
   "oval",
   "arrow"
 ]);
-var ARROW_SIZES = /* @__PURE__ */ new Set(["sm", "med", "lg"]);
+var ARROW_SIZES2 = /* @__PURE__ */ new Set(["sm", "med", "lg"]);
 function parseCustomGeometry(custGeom, orderedCustGeom) {
   const pathLst = getChild(custGeom, "pathLst");
   const paths = getChildArray(pathLst, "path");
@@ -7595,8 +7787,10 @@ function parseShape(sp, partPath, nextId, orderingSlot, orderedNode) {
 function parseConnector(cxnSp, partPath, nextId, orderingSlot, orderedNode) {
   const nvCxnSpPr = getChild(cxnSp, "nvCxnSpPr");
   const cNvPr = getChild(nvCxnSpPr, "cNvPr");
+  const cNvCxnSpPr = getChild(nvCxnSpPr, "cNvCxnSpPr");
   const nodeId = sourceNodeId(cNvPr);
   const name = getAttr(cNvPr, "name");
+  const connection = parseConnectorConnection(cNvCxnSpPr);
   const spPr = getChild(cxnSp, "spPr");
   const transform = parseTransform(spPr);
   const geometry = parseGeometry(spPr, orderedNestedChildChildren(orderedNode, "cxnSp", "spPr"));
@@ -7612,6 +7806,7 @@ function parseConnector(cxnSp, partPath, nextId, orderingSlot, orderedNode) {
     kind: "connector",
     ...nodeId !== void 0 ? { nodeId } : {},
     ...name !== void 0 ? { name } : {},
+    ...connection !== void 0 ? { connection } : {},
     ...transform !== void 0 ? { transform } : {},
     ...geometry !== void 0 ? { geometry } : {},
     ...outline !== void 0 ? { outline } : {},
@@ -7621,6 +7816,23 @@ function parseConnector(cxnSp, partPath, nextId, orderingSlot, orderedNode) {
     ...rawSidecars.length > 0 ? { rawSidecars } : {}
   };
 }
+function parseConnectorConnection(cNvCxnSpPr) {
+  const start = parseConnectorConnectionEndpoint(getChild(cNvCxnSpPr, "stCxn"));
+  const end = parseConnectorConnectionEndpoint(getChild(cNvCxnSpPr, "endCxn"));
+  return start !== void 0 || end !== void 0 ? {
+    ...start !== void 0 ? { start } : {},
+    ...end !== void 0 ? { end } : {}
+  } : void 0;
+}
+function parseConnectorConnectionEndpoint(node) {
+  const shapeId = getAttr(node, "id");
+  const connectionSiteIndex = numericAttr(node, "idx");
+  if (shapeId === void 0 || connectionSiteIndex === void 0) return void 0;
+  return {
+    shapeId: asSourceNodeId(shapeId),
+    connectionSiteIndex
+  };
+}
 function parseShapeStyle(style) {
   if (style === void 0) return void 0;
   const fillRef = parseStyleReference(getChild(style, "fillRef"));
@@ -8501,49 +8713,6 @@ function getPlaceholderFallbackType(type) {
   if (type === "subTitle") return "body";
   return void 0;
 }
-var RELS_SUFFIX = ".rels";
-var RELS_MARKER = "_rels/";
-var ABSOLUTE_URI_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
-function isRelationshipPart(path) {
-  return path.endsWith(RELS_SUFFIX) && path.includes(RELS_MARKER);
-}
-function relationshipsSourcePartPath(relsPath) {
-  const idx = relsPath.lastIndexOf(RELS_MARKER);
-  const dir = relsPath.slice(0, idx);
-  const file = relsPath.slice(idx + RELS_MARKER.length);
-  const base = file.endsWith(RELS_SUFFIX) ? file.slice(0, -RELS_SUFFIX.length) : file;
-  return asPartPath(dir + base);
-}
-function resolveRelationshipTarget(sourcePartPath, target) {
-  if (ABSOLUTE_URI_PATTERN.test(target)) return target;
-  const combined = target.startsWith("/") ? target.slice(1) : joinPackageRelativeTarget(sourcePartPath, target);
-  return normalizePackagePath(combined);
-}
-function resolveInternalRelationshipTarget(sourcePartPath, relationship) {
-  if (relationship.targetMode === "External") return void 0;
-  return asPartPath(resolveRelationshipTarget(sourcePartPath, relationship.target));
-}
-function parseRelationshipTargetMode(value) {
-  if (value === "Internal" || value === "External") return value;
-  return void 0;
-}
-function joinPackageRelativeTarget(sourcePartPath, target) {
-  const slash = sourcePartPath.lastIndexOf("/");
-  const baseDir = slash === -1 ? "" : sourcePartPath.slice(0, slash);
-  return baseDir === "" ? target : `${baseDir}/${target}`;
-}
-function normalizePackagePath(path) {
-  const segments = [];
-  for (const segment of path.split("/")) {
-    if (segment === "" || segment === ".") continue;
-    if (segment === "..") {
-      segments.pop();
-      continue;
-    }
-    segments.push(segment);
-  }
-  return segments.join("/");
-}
 function resolveComputedRelationships(source, sourcePartPath) {
   const rels = source.packageGraph.relationships.find((entry) => entry.sourcePartPath === sourcePartPath)?.relationships ?? [];
   return rels.map((relationship) => {
@@ -8565,7 +8734,7 @@ function resolveComputedRelationships(source, sourcePartPath) {
 function findMedia(media, partPath) {
   return media.find((part) => part.partPath === partPath);
 }
-var IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+var IMAGE_REL_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
 var CHART_REL_TYPES = /* @__PURE__ */ new Set([
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
   "http://purl.oclc.org/ooxml/officeDocument/relationships/chart"
@@ -8782,7 +8951,7 @@ function computeShapeElement(context, shape, layer, partPath) {
 }
 function computeImageElement(context, image, layer, partPath) {
   const relationship = resolveComputedRelationships(context.source, partPath).find(
-    (rel) => rel.id === image.blipRelationshipId && rel.type === IMAGE_REL_TYPE
+    (rel) => rel.id === image.blipRelationshipId && rel.type === IMAGE_REL_TYPE2
   );
   const effects = image.effects !== void 0 ? computeEffectList(context, image.effects) : void 0;
   const blipEffects = image.blipEffects !== void 0 ? computeBlipEffects(context, image.blipEffects) : void 0;
@@ -8980,7 +9149,7 @@ function computeFill(context, fill, partPath) {
       };
     case "image": {
       const relationship = resolveComputedRelationships(context.source, partPath).find(
-        (rel) => rel.id === fill.blipRelationshipId && rel.type === IMAGE_REL_TYPE
+        (rel) => rel.id === fill.blipRelationshipId && rel.type === IMAGE_REL_TYPE2
       );
       return {
         kind: "image",
@@ -9346,6 +9515,7 @@ function parseSlide(root, partPath, layoutPartPath, nextId, orderedSpTree) {
 function parseSlideLayout(root, partPath, masterPartPath, nextId, orderedSpTree) {
   const cSld = getChild(root, "cSld");
   const type = getAttr(root, "type");
+  const show = booleanAttr(root, "show");
   const background = parseBackground(getChild(cSld, "bg"), nextId);
   const colorMapOverride = parseColorMapOverride(getChild(root, "clrMapOvr"));
   const showMasterShapes = booleanAttr(root, "showMasterSp");
@@ -9353,6 +9523,7 @@ function parseSlideLayout(root, partPath, masterPartPath, nextId, orderedSpTree)
     partPath,
     masterPartPath,
     ...type !== void 0 ? { type } : {},
+    ...show !== void 0 ? { show } : {},
     ...background !== void 0 ? { background } : {},
     ...colorMapOverride !== void 0 ? { colorMapOverride } : {},
     ...showMasterShapes !== void 0 ? { showMasterShapes } : {},
@@ -9587,21 +9758,21 @@ function isNonEmpty(value) {
 var CONTENT_TYPES_PART = "[Content_Types].xml";
 var PACKAGE_ROOT_PART = "";
 var OFFICE_DOCUMENT_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
-var SLIDE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
-var SLIDE_LAYOUT_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+var SLIDE_REL_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
+var SLIDE_LAYOUT_REL_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
 var SLIDE_MASTER_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
 var THEME_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
 var PRESENTATION_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml";
 var textDecoder2 = new TextDecoder();
 function readPptx(input) {
-  const entries2 = unzipPackage(input);
+  const entries = unzipPackage(input);
   const diagnostics = [];
-  const contentTypes = readContentTypes(entries2);
-  const relationships = readRelationships(entries2);
+  const contentTypes = readContentTypes(entries);
+  const relationships = readRelationships(entries);
   const parts = [];
   const media = [];
   const rawParts = [];
-  for (const [path, bytes] of entries2) {
+  for (const [path, bytes] of entries) {
     if (path === CONTENT_TYPES_PART) continue;
     const contentType = resolveContentType(path, contentTypes.defaults, contentTypes.overrides);
     parts.push({ partPath: asPartPath(path), contentType });
@@ -9613,12 +9784,12 @@ function readPptx(input) {
     rawParts.push({ kind: "binary", partPath: asPartPath(path), contentType, bytes });
   }
   const presentation = readPresentation(
-    entries2,
+    entries,
     relationships,
     contentTypes.overrides,
     diagnostics
   );
-  const hierarchy = readSlideHierarchy(entries2, relationships, presentation, diagnostics);
+  const hierarchy = readSlideHierarchy(entries, relationships, presentation, diagnostics);
   return {
     packageGraph: {
       contentTypes,
@@ -9635,13 +9806,13 @@ function readPptx(input) {
     diagnostics
   };
 }
-function readSlideHierarchy(entries2, relationships, presentation, diagnostics) {
+function readSlideHierarchy(entries, relationships, presentation, diagnostics) {
   const slides = [];
   const layoutPaths = new OrderedPathSet();
   for (const slidePath of presentation.slidePartPaths) {
-    const part = parsePartRoot(entries2, slidePath, "sld", diagnostics, true);
+    const part = parsePartRoot(entries, slidePath, "sld", diagnostics, true);
     if (part === void 0) continue;
-    const layoutPath = resolveSingleRel(relationships, slidePath, SLIDE_LAYOUT_REL_TYPE);
+    const layoutPath = resolveSingleRel(relationships, slidePath, SLIDE_LAYOUT_REL_TYPE2);
     if (layoutPath === void 0) {
       diagnostics.push({
         severity: "warning",
@@ -9665,7 +9836,7 @@ function readSlideHierarchy(entries2, relationships, presentation, diagnostics)
   const slideLayouts = [];
   const masterPaths = new OrderedPathSet();
   for (const layoutPath of layoutPaths.values()) {
-    const part = parsePartRoot(entries2, layoutPath, "sldLayout", diagnostics, true);
+    const part = parsePartRoot(entries, layoutPath, "sldLayout", diagnostics, true);
     if (part === void 0) continue;
     const masterPath = resolveSingleRel(relationships, layoutPath, SLIDE_MASTER_REL_TYPE);
     if (masterPath !== void 0) masterPaths.add(masterPath);
@@ -9679,14 +9850,21 @@ function readSlideHierarchy(entries2, relationships, presentation, diagnostics)
       )
     );
   }
+  for (const masterPath of resolveAllRels(
+    relationships,
+    presentation.partPath,
+    SLIDE_MASTER_REL_TYPE
+  )) {
+    masterPaths.add(masterPath);
+  }
   const slideMasters = [];
   const themePaths = new OrderedPathSet();
   for (const masterPath of masterPaths.values()) {
-    const part = parsePartRoot(entries2, masterPath, "sldMaster", diagnostics, true);
+    const part = parsePartRoot(entries, masterPath, "sldMaster", diagnostics, true);
     if (part === void 0) continue;
     const themePath = resolveSingleRel(relationships, masterPath, THEME_REL_TYPE);
     if (themePath !== void 0) themePaths.add(themePath);
-    const masterLayoutPaths = resolveAllRels(relationships, masterPath, SLIDE_LAYOUT_REL_TYPE);
+    const masterLayoutPaths = resolveAllRels(relationships, masterPath, SLIDE_LAYOUT_REL_TYPE2);
     slideMasters.push(
       parseSlideMaster(
         part.root,
@@ -9698,9 +9876,26 @@ function readSlideHierarchy(entries2, relationships, presentation, diagnostics)
       )
     );
   }
+  const readLayoutPaths = new Set(slideLayouts.map((layout) => layout.partPath));
+  for (const layoutPath of slideMasters.flatMap((master) => master.layoutPartPaths)) {
+    if (readLayoutPaths.has(layoutPath)) continue;
+    const part = parsePartRoot(entries, layoutPath, "sldLayout", diagnostics, true);
+    if (part === void 0) continue;
+    const masterPath = resolveSingleRel(relationships, layoutPath, SLIDE_MASTER_REL_TYPE);
+    slideLayouts.push(
+      parseSlideLayout(
+        part.root,
+        layoutPath,
+        masterPath ?? asPartPath(""),
+        createSidecarIdFactory(layoutPath),
+        navigateOrdered(part.orderedRoot, ["cSld", "spTree"])
+      )
+    );
+    readLayoutPaths.add(layoutPath);
+  }
   const themes = [];
   for (const themePath of themePaths.values()) {
-    const part = parsePartRoot(entries2, themePath, "theme", diagnostics, true);
+    const part = parsePartRoot(entries, themePath, "theme", diagnostics, true);
     if (part === void 0) continue;
     themes.push(
       parseTheme(part.root, themePath, createSidecarIdFactory(themePath), part.orderedRoot)
@@ -9708,8 +9903,8 @@ function readSlideHierarchy(entries2, relationships, presentation, diagnostics)
   }
   return { slides, slideLayouts, slideMasters, themes };
 }
-function parsePartRoot(entries2, partPath, rootLocalName, diagnostics, includeOrderedRoot) {
-  const bytes = entries2.get(partPath);
+function parsePartRoot(entries, partPath, rootLocalName, diagnostics, includeOrderedRoot) {
+  const bytes = entries.get(partPath);
   if (!bytes) {
     diagnostics.push({
       severity: "warning",
@@ -9760,15 +9955,15 @@ var OrderedPathSet = class {
 };
 function unzipPackage(input) {
   const unzipped = (0, import_fflate.unzipSync)(input);
-  const entries2 = /* @__PURE__ */ new Map();
+  const entries = /* @__PURE__ */ new Map();
   for (const [path, bytes] of Object.entries(unzipped)) {
     if (path.endsWith("/")) continue;
-    entries2.set(path, bytes);
+    entries.set(path, bytes);
   }
-  return entries2;
+  return entries;
 }
-function readContentTypes(entries2) {
-  const bytes = entries2.get(CONTENT_TYPES_PART);
+function readContentTypes(entries) {
+  const bytes = entries.get(CONTENT_TYPES_PART);
   if (!bytes) return { defaults: [], overrides: [] };
   const root = getChild(parseXml(textDecoder2.decode(bytes)), "Types");
   const defaults = [];
@@ -9787,9 +9982,9 @@ function readContentTypes(entries2) {
   }
   return { defaults, overrides };
 }
-function readRelationships(entries2) {
+function readRelationships(entries) {
   const result = [];
-  for (const [path, bytes] of entries2) {
+  for (const [path, bytes] of entries) {
     if (!isRelationshipPart(path)) continue;
     const root = getChild(parseXml(textDecoder2.decode(bytes)), "Relationships");
     const relationships = [];
@@ -9810,12 +10005,12 @@ function readRelationships(entries2) {
   }
   return result;
 }
-function readPresentation(entries2, relationships, overrides, diagnostics) {
+function readPresentation(entries, relationships, overrides, diagnostics) {
   const presentationPath = locatePresentationPart(relationships, overrides);
   if (presentationPath === void 0) {
     throw new Error("readPptx: presentation part not found; input is not a valid PPTX package");
   }
-  const bytes = entries2.get(presentationPath);
+  const bytes = entries.get(presentationPath);
   if (!bytes) {
     throw new Error(
       `readPptx: presentation part '${presentationPath}' is missing from the package`
@@ -9849,7 +10044,7 @@ function readPresentation(entries2, relationships, overrides, diagnostics) {
       });
       continue;
     }
-    if (relationship.type !== SLIDE_REL_TYPE || relationship.targetMode === "External") {
+    if (relationship.type !== SLIDE_REL_TYPE2 || relationship.targetMode === "External") {
       diagnostics.push({
         severity: "warning",
         code: "slide-relationship-invalid",
@@ -10572,74 +10767,65 @@ function pushAdapterWarning(diagnostics, code, message, slide, sourcePartPath) {
 
 // src/svg-converter.ts
 async function convertPptxToSvg(input, options, loadSystemFontSetup2) {
+  const source = readPptx(input);
+  return renderPptxSourceModelToSvg(source, options, loadSystemFontSetup2);
+}
+async function renderPptxSourceModelToSvg(source, options, loadSystemFontSetup2) {
   const textOutput = options?.textOutput ?? "path";
   const logLevel = options?.logLevel ?? "off";
   const setup = await createOpentypeSetup(options, loadSystemFontSetup2);
-  if (setup) {
-    setTextMeasurer(setup.measurer);
-    if (textOutput !== "text") {
-      setTextPathFontResolver(setup.fontResolver);
-    }
-  }
   const fontUsageCollector = textOutput === "text" ? new FontUsageCollector() : null;
-  if (fontUsageCollector) {
-    setFontUsageCollector(fontUsageCollector);
+  const scriptFontScheme = findScriptFontScheme(source);
+  const warningLogger = createWarningLogger(logLevel === "off" ? "warn" : logLevel);
+  const context = createRendererContext({
+    ...setup !== null ? { textMeasurer: setup.measurer } : {},
+    textPathFontResolver: setup !== null && textOutput !== "text" ? setup.fontResolver : null,
+    fontUsageCollector,
+    fontMapping: createFontMapping(options?.fontMapping),
+    scriptFonts: {
+      majorJpan: scriptFontScheme?.majorJapanese ?? null,
+      minorJpan: scriptFontScheme?.minorJapanese ?? null
+    },
+    warningLogger
+  });
+  if (source.presentation.slidePartPaths.length === 0) {
+    context.warningLogger.warn("presentation.noSlides", "No slides found in the PPTX file");
   }
-  setFontMapping(createFontMapping(options?.fontMapping));
-  try {
-    initWarningLogger(logLevel === "off" ? "warn" : logLevel);
-    const source = readPptx(input);
-    const scriptFontScheme = findScriptFontScheme(source);
-    setScriptFonts(
-      scriptFontScheme?.majorJapanese ?? null,
-      scriptFontScheme?.minorJapanese ?? null
-    );
-    if (source.presentation.slidePartPaths.length === 0) {
-      warn("presentation.noSlides", "No slides found in the PPTX file");
-    }
-    const computed = createComputedView(source, { slides: options?.slides });
-    const adapted = adaptComputedViewToRendererModel(computed);
-    const slideSize = adapted.slideSize;
-    if (slideSize === void 0 && adapted.slides.length > 0) {
-      throw new Error("Converter requires a computed slide size");
-    }
-    const slides = [];
-    for (const slide of adapted.slides) {
-      if (slideSize === void 0) continue;
-      fontUsageCollector?.reset();
-      let svg = renderSlideToSvg(slide, slideSize);
-      if (fontUsageCollector && setup) {
-        const style = await buildFontFaceStyle(fontUsageCollector.getUsages(), setup.fontResolver);
-        if (style) {
-          svg = injectIntoSvgDefs(svg, style);
-        }
+  const computed = createComputedView(source, { slides: options?.slides });
+  const adapted = adaptComputedViewToRendererModel(computed);
+  const slideSize = adapted.slideSize;
+  if (slideSize === void 0 && adapted.slides.length > 0) {
+    throw new Error("Converter requires a computed slide size");
+  }
+  const slides = [];
+  for (const slide of adapted.slides) {
+    if (slideSize === void 0) continue;
+    fontUsageCollector?.reset();
+    let svg = renderSlideToSvg(slide, slideSize, context);
+    if (fontUsageCollector && setup) {
+      const style = await buildFontFaceStyle(
+        fontUsageCollector.getUsages(),
+        setup.fontResolver,
+        context
+      );
+      if (style) {
+        svg = injectIntoSvgDefs(svg, style);
       }
-      slides.push({ slideNumber: slide.slideNumber, svg });
     }
-    const rendererWarningEntries = [...getWarningEntries()];
-    if (logLevel === "off") {
-      initWarningLogger("off");
-    } else {
-      flushWarnings();
-    }
-    const diagnostics = [
-      ...normalizeDocumentDiagnostics(source.diagnostics),
-      ...collectSmartArtComputedViewDiagnostics(computed),
-      ...normalizeRendererAdapterDiagnostics(adapted.diagnostics),
-      ...normalizeRendererWarningDiagnostics(rendererWarningEntries)
-    ];
-    const supportCoverage = buildSupportCoverage(computed, adapted.slides, diagnostics);
-    return { slides, diagnostics, supportCoverage };
-  } finally {
-    if (logLevel === "off") {
-      initWarningLogger("off");
-    }
-    resetTextMeasurer();
-    resetTextPathFontResolver();
-    resetFontUsageCollector();
-    resetFontMapping();
-    resetScriptFonts();
+    slides.push({ slideNumber: slide.slideNumber, svg });
   }
+  const rendererWarningEntries = [...context.warningLogger.getWarningEntries()];
+  if (logLevel !== "off") {
+    context.warningLogger.flushWarnings();
+  }
+  const diagnostics = [
+    ...normalizeDocumentDiagnostics(source.diagnostics),
+    ...collectSmartArtComputedViewDiagnostics(computed),
+    ...normalizeRendererAdapterDiagnostics(adapted.diagnostics),
+    ...normalizeRendererWarningDiagnostics(rendererWarningEntries)
+  ];
+  const supportCoverage = buildSupportCoverage(computed, adapted.slides, diagnostics);
+  return { slides, diagnostics, supportCoverage };
 }
 function findScriptFontScheme(source) {
   const firstThemePartPath = source.slideMasters.find(
@@ -10812,6 +10998,9 @@ function shouldLoadSystemFonts(options) {
 async function convertPptxToSvg2(input, options) {
   return convertPptxToSvg(input, options, loadSystemFontSetup);
 }
+async function renderPptxSourceModelToSvg2(source, options) {
+  return renderPptxSourceModelToSvg(source, options, loadSystemFontSetup);
+}
 async function convertPptxToPng(input, options) {
   const svgResult = await convertPptxToSvg2(input, {
     ...options,
@@ -11022,5 +11211,6 @@ async function initResvgWasm2(wasm) {
   getMappedFont,
   getWarningEntries,
   getWarningSummary,
-  initResvgWasm
+  initResvgWasm,
+  renderPptxSourceModelToSvg
 });