pptx-glimpse 3.0.0 → 3.1.0

package/dist/{chunk-2AYNMYMC.js → chunk-PGCREQQU.js}

@@ -1,62 +1,3 @@
-// ../renderer/src/warning-logger.ts
-var PREFIX = "[pptx-glimpse]";
-var currentLevel = "off";
-var entries = [];
-var featureCounts = /* @__PURE__ */ new Map();
-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;
-}
-
 // ../renderer/src/font/font-mapping.ts
 var DEFAULT_FONT_MAPPING = {
   // Latin fonts
@@ -111,6 +52,81 @@ function getMappedFont(fontFamily, mapping) {
   return null;
 }
 
+// ../renderer/src/warning-logger.ts
+var PREFIX = "[pptx-glimpse]";
+var 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 });
+    }
+  }
+};
+var activeLogger = createWarningLogger("off");
+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();
+}
+
 // ../renderer/src/unsafe-type-assertion.ts
 function unsafeExternalInteropAssertion(value) {
   return value;
@@ -1099,11 +1115,8 @@ function getCjkFallbackFonts(mappedFontName) {
 
 // ../renderer/src/font/font-mapping-context.ts
 var currentMapping = { ...DEFAULT_FONT_MAPPING };
-function setFontMapping(mapping) {
-  currentMapping = mapping;
-}
-function resetFontMapping() {
-  currentMapping = { ...DEFAULT_FONT_MAPPING };
+function getFontMapping() {
+  return currentMapping;
 }
 function getCurrentMappedFont(fontFamily) {
   return getMappedFont(fontFamily, currentMapping);
@@ -1113,20 +1126,22 @@ function getCurrentMappedFont(fontFamily) {
 var PX_PER_PT2 = 96 / 72;
 var BOLD_FACTOR2 = 1.05;
 var 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);
@@ -1134,7 +1149,7 @@ var OpentypeTextMeasurer = class {
     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();
@@ -1166,26 +1181,26 @@ var OpentypeTextMeasurer = class {
     }
     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;
@@ -1194,11 +1209,11 @@ var OpentypeTextMeasurer = class {
     }
     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;
@@ -1207,12 +1222,19 @@ var OpentypeTextMeasurer = class {
         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;
   }
+  getMappedFont(name, context) {
+    return context?.fontMapping !== void 0 ? getMappedFont(name, context.fontMapping) : this.fontMapping !== void 0 ? getMappedFont(name, this.fontMapping) : getCurrentMappedFont(name);
+  }
 };
 
 // ../renderer/src/font/text-path-context.ts
@@ -1224,31 +1246,40 @@ var DefaultTextPathFontResolver = class {
     this.fonts = fonts;
     this.defaultFont = defaultFont ?? null;
   }
-  resolveFont(fontFamily, fontFamilyEa, jpanFallback) {
+  resolveFont(fontFamily, fontFamilyEa, jpanFallback, context) {
     if (fontFamily) {
-      const font = this.findFont(fontFamily);
+      const font = this.findFont(fontFamily, context);
       if (font) return font;
     }
     if (fontFamilyEa) {
-      const font = this.findFont(fontFamilyEa);
+      const font = this.findFont(fontFamilyEa, context);
       if (font) return font;
     }
     if (jpanFallback) {
-      const font = this.findFont(jpanFallback);
+      const font = this.findFont(jpanFallback, context);
       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}"`);
+      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) {
+  findFont(name, context) {
     const direct = this.fonts.get(name);
     if (direct) return direct;
-    const mapped = getCurrentMappedFont(name);
+    const mapped = context?.fontMapping !== void 0 ? getMappedFont(name, context.fontMapping) : getCurrentMappedFont(name);
     if (mapped) {
       const mappedFont = this.fonts.get(mapped);
       if (mappedFont) return mappedFont;
@@ -1261,15 +1292,9 @@ var DefaultTextPathFontResolver = class {
   }
 };
 var currentResolver = null;
-function setTextPathFontResolver(resolver) {
-  currentResolver = resolver;
-}
 function getTextPathFontResolver() {
   return currentResolver;
 }
-function resetTextPathFontResolver() {
-  currentResolver = null;
-}
 
 // ../renderer/src/font/ttc-parser.ts
 var TTC_TAG = 1953784678;
@@ -1461,11 +1486,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,
@@ -1494,7 +1520,7 @@ async function createOpentypeSetupFromBuffers(fontBuffers, fontMapping) {
     } catch {
     }
   }
-  return buildOpentypeSetupFromState(state);
+  return buildOpentypeSetupFromState(state, mapping);
 }
 var SYSTEM_FONT_CACHE_KEY = "__pptxGlimpseSystemFontCache__";
 function getSystemFontCacheStore() {
@@ -1519,26 +1545,21 @@ function clearFontCache() {
 
 export {
   getMetricsFallbackFont,
-  unsafeExternalInteropAssertion,
-  unsafeBrandAssertion,
-  initWarningLogger,
-  warn,
-  debug,
-  getWarningSummary,
-  flushWarnings,
-  getWarningEntries,
   DEFAULT_FONT_MAPPING,
   createFontMapping,
   getMappedFont,
-  setFontMapping,
-  resetFontMapping,
-  getCurrentMappedFont,
+  getFontMapping,
   getLineHeightRatio,
   getAscenderRatio,
   measureTextWidth,
-  setTextPathFontResolver,
+  createWarningLogger,
+  getActiveWarningLogger,
+  warn,
+  getWarningSummary,
+  getWarningEntries,
   getTextPathFontResolver,
-  resetTextPathFontResolver,
+  unsafeExternalInteropAssertion,
+  unsafeBrandAssertion,
   tryLoadOpentype,
   buildReverseMapping,
   toArrayBuffer,

package/dist/{chunk-MWMHSSAD.js → chunk-WAMKNW47.js}

@@ -9,7 +9,7 @@ import {
   setCachedSystemOpentypeSetup,
   toArrayBuffer,
   tryLoadOpentype
-} from "./chunk-2AYNMYMC.js";
+} from "./chunk-PGCREQQU.js";
 
 // ../renderer/src/font/opentype-system-helpers.ts
 import { readFile } from "fs/promises";
@@ -99,7 +99,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 {
@@ -112,7 +113,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;

package/dist/chunk-XGCLQP2P.js

@@ -0,0 +1,83 @@
+import {
+  DEFAULT_OUTPUT_WIDTH,
+  convertPptxToSvg,
+  renderPptxSourceModelToSvg
+} from "./chunk-NMAO44T7.js";
+
+// src/converter.ts
+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,
+    textOutput: "path"
+  });
+  const width = options?.width ?? DEFAULT_OUTPUT_WIDTH;
+  const height = options?.height;
+  const fontBuffers = await loadPngFontBuffers(options);
+  const slides = [];
+  for (const { slideNumber, svg } of svgResult.slides) {
+    const pngResult = await convertSvgToPng(svg, { width, height, fontBuffers });
+    slides.push({
+      slideNumber,
+      png: toPlainUint8Array(pngResult.png),
+      width: pngResult.width,
+      height: pngResult.height
+    });
+  }
+  return {
+    slides,
+    diagnostics: svgResult.diagnostics,
+    supportCoverage: svgResult.supportCoverage
+  };
+}
+var loadSystemFontSetup = async (options) => {
+  if (!shouldLoadSystemFonts(options)) {
+    return null;
+  }
+  const { createOpentypeSetupFromSystem } = await import(
+    /* @vite-ignore */
+    "./node-E6UXPQSQ.js"
+  );
+  return createOpentypeSetupFromSystem(
+    options?.fontDirs,
+    options?.fontMapping,
+    options?.skipSystemFonts
+  );
+};
+async function loadPngFontBuffers(options) {
+  if (options?.fonts !== void 0) {
+    return options.fonts.map((font) => toUint8Array(font.data));
+  }
+  if (!shouldLoadSystemFonts(options)) {
+    return [];
+  }
+  const { loadFontBuffersFromSystem } = await import(
+    /* @vite-ignore */
+    "./node-font-loader-OE3OLNDI.js"
+  );
+  return loadFontBuffersFromSystem(options?.fontDirs, options?.skipSystemFonts);
+}
+async function convertSvgToPng(svg, options) {
+  const { svgToPng } = await import("./png-IONMVVDQ.js");
+  return svgToPng(svg, options);
+}
+function shouldLoadSystemFonts(options) {
+  return options?.skipSystemFonts !== true || (options?.fontDirs?.length ?? 0) > 0;
+}
+function toUint8Array(data) {
+  return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+function toPlainUint8Array(data) {
+  return new Uint8Array(data);
+}
+
+export {
+  convertPptxToSvg2 as convertPptxToSvg,
+  renderPptxSourceModelToSvg2 as renderPptxSourceModelToSvg,
+  convertPptxToPng
+};

package/dist/chunk-ZZKN4U5J.js

@@ -0,0 +1,141 @@
+import {
+  createComputedView,
+  readPptx
+} from "./chunk-NMAO44T7.js";
+
+// src/font/font-collector.ts
+var DEFAULT_THEME_FONTS = {
+  majorLatin: "Calibri",
+  minorLatin: "Calibri"
+};
+function collectUsedFonts(input) {
+  const source = readPptx(input);
+  const defaultFontScheme = findDefaultThemeFontScheme(source);
+  const computed = createComputedView(source);
+  const fonts = /* @__PURE__ */ new Set();
+  collectThemeFonts(defaultFontScheme, fonts);
+  const visitedTemplateParts = /* @__PURE__ */ new Set();
+  for (const slide of computed.slides) {
+    const slideFontScheme = findThemeFontScheme(source, slide.themePartPath) ?? defaultFontScheme;
+    const templateElementsByPart = /* @__PURE__ */ new Map();
+    for (const element of slide.elements) {
+      if (element.sourceLayer === "slide") {
+        collectFontsFromElements([element], fonts, slideFontScheme);
+        continue;
+      }
+      const key = `${element.sourceLayer}:${element.sourcePartPath}`;
+      const elements = templateElementsByPart.get(key);
+      if (elements) {
+        elements.push(element);
+      } else {
+        templateElementsByPart.set(key, [element]);
+      }
+    }
+    for (const [key, elements] of templateElementsByPart) {
+      if (visitedTemplateParts.has(key)) continue;
+      visitedTemplateParts.add(key);
+      collectFontsFromElements(elements, fonts, slideFontScheme);
+    }
+  }
+  return {
+    theme: {
+      majorFont: defaultFontScheme.majorLatin,
+      minorFont: defaultFontScheme.minorLatin,
+      majorFontEa: defaultFontScheme.majorEastAsian ?? null,
+      minorFontEa: defaultFontScheme.minorEastAsian ?? null,
+      majorFontCs: defaultFontScheme.majorComplexScript ?? null,
+      minorFontCs: defaultFontScheme.minorComplexScript ?? null
+    },
+    fonts: [...fonts].sort()
+  };
+}
+function findDefaultThemeFontScheme(source) {
+  const firstThemePartPath = source.slideMasters.find(
+    (master) => master.themePartPath !== void 0
+  )?.themePartPath;
+  const scheme = findThemeFontScheme(source, firstThemePartPath) ?? source.themes[0]?.fontScheme;
+  return applyDefaultThemeFonts(scheme);
+}
+function findThemeFontScheme(source, themePartPath) {
+  if (themePartPath === void 0) return void 0;
+  const scheme = source.themes.find((theme) => theme.partPath === themePartPath)?.fontScheme;
+  return scheme !== void 0 ? applyDefaultThemeFonts(scheme) : void 0;
+}
+function applyDefaultThemeFonts(scheme) {
+  return {
+    ...DEFAULT_THEME_FONTS,
+    ...scheme
+  };
+}
+function collectThemeFonts(fontScheme, fonts) {
+  addFont(fonts, fontScheme.majorLatin, fontScheme);
+  addFont(fonts, fontScheme.minorLatin, fontScheme);
+  addFont(fonts, fontScheme.majorEastAsian, fontScheme);
+  addFont(fonts, fontScheme.minorEastAsian, fontScheme);
+  addFont(fonts, fontScheme.majorComplexScript, fontScheme);
+  addFont(fonts, fontScheme.minorComplexScript, fontScheme);
+  addFont(fonts, fontScheme.majorJapanese, fontScheme);
+  addFont(fonts, fontScheme.minorJapanese, fontScheme);
+}
+function collectFontsFromElements(elements, fonts, fontScheme) {
+  for (const el of elements) {
+    switch (el.kind) {
+      case "shape":
+        if (el.textBody) collectFontsFromTextBody(el.textBody, fonts, fontScheme);
+        break;
+      case "group":
+        collectFontsFromElements(el.children, fonts, fontScheme);
+        break;
+      case "table":
+        for (const row of el.table.rows) {
+          for (const cell of row.cells) {
+            if (cell.textBody) collectFontsFromTextBody(cell.textBody, fonts, fontScheme);
+          }
+        }
+        break;
+      case "connector":
+      case "image":
+      case "chart":
+      case "smartArt":
+      case "raw":
+        break;
+    }
+  }
+}
+function collectFontsFromTextBody(textBody, fonts, fontScheme) {
+  for (const para of textBody.paragraphs) {
+    addFont(fonts, para.properties?.bulletFont, fontScheme);
+    for (const run of para.runs) {
+      addFont(fonts, run.properties?.typeface, fontScheme);
+      addFont(fonts, run.properties?.typefaceEa, fontScheme);
+      addFont(fonts, run.properties?.typefaceCs, fontScheme);
+    }
+  }
+}
+function addFont(fonts, font, fontScheme) {
+  const resolved = resolveThemeFontAlias(font, fontScheme);
+  if (resolved) fonts.add(resolved);
+}
+function resolveThemeFontAlias(font, fontScheme) {
+  if (font === void 0) return void 0;
+  switch (font) {
+    case "+mj-lt":
+      return fontScheme.majorLatin;
+    case "+mn-lt":
+      return fontScheme.minorLatin;
+    case "+mj-ea":
+      return fontScheme.majorEastAsian ?? fontScheme.majorJapanese;
+    case "+mn-ea":
+      return fontScheme.minorEastAsian ?? fontScheme.minorJapanese;
+    case "+mj-cs":
+      return fontScheme.majorComplexScript;
+    case "+mn-cs":
+      return fontScheme.minorComplexScript;
+    default:
+      return font.startsWith("+mj-") || font.startsWith("+mn-") ? void 0 : font;
+  }
+}
+
+export {
+  collectUsedFonts
+};