pptx-glimpse 2.0.0 → 3.1.0

package/dist/chunk-QPT6BMN5.js

@@ -0,0 +1,25 @@
+// ../renderer/src/png/render-svg.ts
+import { Resvg } from "@resvg/resvg-wasm";
+function renderSvgToPng(svgString, options) {
+  const resvgOptions = {};
+  if (options?.width) {
+    resvgOptions.fitTo = { mode: "width", value: options.width };
+  } else if (options?.height) {
+    resvgOptions.fitTo = { mode: "height", value: options.height };
+  }
+  const fontBuffers = options?.fontBuffers;
+  if (fontBuffers && fontBuffers.length > 0) {
+    resvgOptions.font = { fontBuffers };
+  }
+  const resvg = new Resvg(svgString, resvgOptions);
+  const rendered = resvg.render();
+  return {
+    png: new Uint8Array(rendered.asPng()),
+    width: rendered.width,
+    height: rendered.height
+  };
+}
+
+export {
+  renderSvgToPng
+};

package/dist/chunk-WAMKNW47.js

@@ -0,0 +1,125 @@
+import {
+  buildOpentypeSetupFromState,
+  buildReverseMapping,
+  createFontMapping,
+  createOpentypeSetupState,
+  getCachedSystemOpentypeSetup,
+  parseFontBuffer,
+  registerParsedFont,
+  setCachedSystemOpentypeSetup,
+  toArrayBuffer,
+  tryLoadOpentype
+} from "./chunk-PGCREQQU.js";
+
+// ../renderer/src/font/opentype-system-helpers.ts
+import { readFile } from "fs/promises";
+
+// ../renderer/src/font/system-font-loader.ts
+import { existsSync, readdirSync } from "fs";
+import { homedir, platform } from "os";
+import { extname, join } from "path";
+var FONT_EXTENSIONS = /* @__PURE__ */ new Set([".ttf", ".otf"]);
+var CJK_TTC_PATTERNS = [
+  "NotoSansCJK",
+  "NotoSerifCJK",
+  // macOS
+  "Hiragino",
+  "\u30D2\u30E9\u30AE\u30CE",
+  // Windows
+  "YuGoth",
+  "YuMin",
+  "meiryo",
+  "msgothic",
+  "msmincho"
+];
+var cachedPaths = null;
+var cachedAdditionalDirs = null;
+var cachedSkipSystemFonts = null;
+function getSystemFontDirs() {
+  const os = platform();
+  if (os === "linux") return ["/usr/share/fonts", "/usr/local/share/fonts"];
+  if (os === "darwin") {
+    return ["/System/Library/Fonts", "/Library/Fonts", join(homedir(), "Library/Fonts")];
+  }
+  if (os === "win32") return ["C:\\Windows\\Fonts"];
+  return [];
+}
+function isCjkTtc(name) {
+  const lower = name.normalize("NFC").toLowerCase();
+  return lower.endsWith(".ttc") && CJK_TTC_PATTERNS.some((p) => lower.includes(p.toLowerCase()));
+}
+function walk(dir, result) {
+  if (!existsSync(dir)) return;
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath, result);
+      } else if (FONT_EXTENSIONS.has(extname(entry.name).toLowerCase()) || isCjkTtc(entry.name)) {
+        result.push(fullPath);
+      }
+    }
+  } catch {
+  }
+}
+function collectFontFilePaths(additionalDirs, skipSystemFonts = false) {
+  const dirs = additionalDirs ?? [];
+  const dirsKey = dirs.join("\0");
+  const cachedKey = cachedAdditionalDirs?.join("\0") ?? null;
+  if (cachedPaths !== null && dirsKey === cachedKey && cachedSkipSystemFonts === skipSystemFonts) {
+    return cachedPaths;
+  }
+  const allDirs = skipSystemFonts ? dirs : [...getSystemFontDirs(), ...dirs];
+  const result = [];
+  for (const dir of allDirs) {
+    walk(dir, result);
+  }
+  result.sort((a, b) => a.localeCompare(b));
+  cachedPaths = result;
+  cachedAdditionalDirs = dirs;
+  cachedSkipSystemFonts = skipSystemFonts;
+  return result;
+}
+
+// ../renderer/src/font/opentype-system-helpers.ts
+function buildCacheKey(additionalFontDirs, fontMapping, skipSystemFonts = false) {
+  const dirsKey = additionalFontDirs ? [...additionalFontDirs].sort().join("\0") : "";
+  const mappingKey = fontMapping ? JSON.stringify(fontMapping, Object.keys(fontMapping).sort()) : "";
+  return `${dirsKey}
+${mappingKey}
+${skipSystemFonts}`;
+}
+async function createOpentypeSetupFromSystem(additionalFontDirs, fontMapping, skipSystemFonts = false) {
+  const key = buildCacheKey(additionalFontDirs, fontMapping, skipSystemFonts);
+  const cached = getCachedSystemOpentypeSetup(key);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const opentype = await tryLoadOpentype();
+  if (!opentype) return null;
+  const fontFilePaths = collectFontFilePaths(additionalFontDirs, skipSystemFonts);
+  if (fontFilePaths.length === 0) return null;
+  const mapping = createFontMapping(fontMapping);
+  const reverseMap = buildReverseMapping(mapping);
+  const state = createOpentypeSetupState();
+  for (const filePath of fontFilePaths) {
+    try {
+      const data = await readFile(filePath);
+      const arrayBuffer = toArrayBuffer(data);
+      const fonts = parseFontBuffer(arrayBuffer, opentype);
+      for (const font of fonts) {
+        registerParsedFont(font, reverseMap, state);
+      }
+    } catch {
+    }
+  }
+  const setup = buildOpentypeSetupFromState(state, mapping);
+  if (setup === null) return null;
+  setCachedSystemOpentypeSetup(key, setup);
+  return setup;
+}
+
+export {
+  collectFontFilePaths,
+  createOpentypeSetupFromSystem
+};

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
+};