pptxtojson-pro 0.1.0

package/src/utils/emfParser.ts

@@ -0,0 +1,298 @@
+/**
+ * EMF (Enhanced Metafile) binary parser — extracts embedded content from EMF files.
+ *
+ * PPTX files frequently embed EMF images as OLE object previews.
+ * Most contain embedded PDF data inside GDI comment records, or DIB bitmaps
+ * via STRETCHDIBITS records. This parser extracts those embedded resources
+ * without implementing full EMF record interpretation.
+ *
+ * EMF record format: each record is { type: u32, size: u32, ...data }
+ * Records are walked sequentially until EOF record (type 14).
+ *
+ * Bitmap output uses a plain RGBA buffer (no browser ImageData) so Node/bundlers work.
+ */
+
+export type RasterBitmap = {
+  width: number;
+  height: number;
+  /** RGBA, length width * height * 4 */
+  data: Uint8ClampedArray;
+};
+
+export type EmfContent =
+  | { type: 'pdf'; data: Uint8Array }
+  | { type: 'bitmap'; bitmap: RasterBitmap }
+  | { type: 'empty' }
+  | { type: 'unsupported' };
+
+// EMF record types
+const EMR_EOF = 14;
+const EMR_COMMENT = 70;
+const EMR_STRETCHDIBITS = 81;
+
+// GDI comment identifiers (MS-EMF spec)
+const GDIC_COMMENT_ID = 0x43494447; // "GDIC"
+const GDIC_BEGINGROUP = 0x00000002;
+const GDIC_MULTIFORMATS = 0x40000004;
+
+// EMF header signature at offset 40
+const EMF_SIGNATURE = 0x464d4520; // " EMF"
+
+// PDF markers
+const PDF_HEADER = [0x25, 0x50, 0x44, 0x46]; // "%PDF"
+const PDF_EOF = [0x25, 0x25, 0x45, 0x4f, 0x46]; // "%%EOF"
+
+// DIB compression
+const BI_RGB = 0;
+
+/**
+ * Parse an EMF file and extract its embedded content.
+ */
+export function parseEmfContent(data: Uint8Array): EmfContent {
+  if (data.length < 44) return { type: 'unsupported' };
+
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+  // Validate EMF signature at offset 40
+  if (view.getUint32(40, true) !== EMF_SIGNATURE) {
+    return { type: 'unsupported' };
+  }
+
+  let offset = 0;
+  let recordCount = 0;
+
+  while (offset + 8 <= data.length) {
+    const recordType = view.getUint32(offset, true);
+    const recordSize = view.getUint32(offset + 4, true);
+
+    // Sanity check record size
+    if (recordSize < 8 || offset + recordSize > data.length) break;
+
+    recordCount++;
+
+    if (recordType === EMR_EOF) break;
+
+    // Check GDI Comment records for embedded PDF
+    if (recordType === EMR_COMMENT && recordSize > 16) {
+      const result = parseGdiComment(data, view, offset, recordSize);
+      if (result) return result;
+    }
+
+    // Check STRETCHDIBITS for embedded bitmaps
+    if (recordType === EMR_STRETCHDIBITS && recordSize > 80) {
+      const result = parseStretchDibits(data, view, offset, recordSize);
+      if (result) return result;
+    }
+
+    offset += recordSize;
+  }
+
+  // Only HEADER + EOF → empty
+  if (recordCount <= 2) {
+    return { type: 'empty' };
+  }
+
+  return { type: 'unsupported' };
+}
+
+/**
+ * Parse a GDI Comment record looking for embedded PDF data.
+ */
+function parseGdiComment(
+  data: Uint8Array,
+  view: DataView,
+  offset: number,
+  recordSize: number,
+): EmfContent | null {
+  // Record layout: type(4) + size(4) + cbData(4) + commentId(4) + ...
+  if (offset + 16 > data.length) return null;
+
+  const commentId = view.getUint32(offset + 12, true);
+
+  if (commentId === GDIC_COMMENT_ID && offset + 20 <= data.length) {
+    const publicType = view.getUint32(offset + 16, true);
+
+    if (publicType === GDIC_BEGINGROUP) {
+      // Search for %PDF signature in the record data
+      const recordData = data.subarray(offset + 8, offset + recordSize);
+      const pdf = extractPdfFromBuffer(recordData);
+      if (pdf) return { type: 'pdf', data: pdf };
+    }
+
+    if (publicType === GDIC_MULTIFORMATS && offset + 24 <= data.length) {
+      // MULTIFORMATS: parse format descriptors and extract first usable one
+      const result = parseMultiformats(data, view, offset, recordSize);
+      if (result) return result;
+    }
+  }
+
+  // Also search non-GDIC comments for raw PDF data
+  if (recordSize > 100) {
+    const recordData = data.subarray(offset + 8, offset + recordSize);
+    const pdf = extractPdfFromBuffer(recordData);
+    if (pdf) return { type: 'pdf', data: pdf };
+  }
+
+  return null;
+}
+
+/**
+ * Parse MULTIFORMATS GDI comment — contains format descriptors pointing to embedded data.
+ */
+function parseMultiformats(
+  data: Uint8Array,
+  view: DataView,
+  offset: number,
+  _recordSize: number,
+): EmfContent | null {
+  // Layout from record start:
+  // +12: commentIdentifier(4), +16: publicCommentIdentifier(4)
+  // +20: outputRect(16 = RECTL)
+  // +36: countFormats(4)
+  // +40: format descriptors array, each: { signature(4), version(4), cbData(4), offData(4) }
+  if (offset + 40 > data.length) return null;
+
+  const countFormats = view.getUint32(offset + 36, true);
+  const descriptorStart = offset + 40;
+
+  for (let i = 0; i < countFormats && i < 10; i++) {
+    const descOff = descriptorStart + i * 16;
+    if (descOff + 16 > data.length) break;
+
+    const cbData = view.getUint32(descOff + 8, true);
+    const offData = view.getUint32(descOff + 12, true);
+
+    // offData is relative to the start of the record
+    const dataStart = offset + offData;
+    if (dataStart + cbData > data.length || cbData === 0) continue;
+
+    const formatData = data.subarray(dataStart, dataStart + cbData);
+    const pdf = extractPdfFromBuffer(formatData);
+    if (pdf) return { type: 'pdf', data: pdf };
+  }
+
+  return null;
+}
+
+/**
+ * Search for %PDF...%%EOF in a buffer and extract the PDF bytes.
+ */
+function extractPdfFromBuffer(buf: Uint8Array): Uint8Array | null {
+  const pdfStart = findSequence(buf, PDF_HEADER);
+  if (pdfStart === -1) return null;
+
+  // Search for %%EOF from the end (PDF may have multiple %%EOF; take the last one)
+  let pdfEnd = -1;
+  for (let i = buf.length - PDF_EOF.length; i >= pdfStart; i--) {
+    if (matchesAt(buf, i, PDF_EOF)) {
+      pdfEnd = i + PDF_EOF.length;
+      break;
+    }
+  }
+
+  if (pdfEnd === -1) {
+    // No %%EOF found — take everything from %PDF to end of buffer
+    pdfEnd = buf.length;
+  }
+
+  return buf.slice(pdfStart, pdfEnd);
+}
+
+/**
+ * Parse a STRETCHDIBITS record and extract the bitmap as RGBA buffer.
+ */
+function parseStretchDibits(
+  data: Uint8Array,
+  view: DataView,
+  offset: number,
+  _recordSize: number,
+): EmfContent | null {
+  // STRETCHDIBITS record layout (offsets from record start):
+  //   0: type(4), 4: size(4)
+  //   8: rclBounds (16 bytes)
+  //  24: xDest(4), 28: yDest(4)
+  //  32: xSrc(4), 36: ySrc(4)
+  //  40: cxSrc(4), 44: cySrc(4)
+  //  48: offBmiSrc(4), 52: cbBmiSrc(4)
+  //  56: offBitsSrc(4), 60: cbBitsSrc(4)
+  //  64: iUsageSrc(4), 68: dwRop(4)
+  //  72: cxDest(4), 76: cyDest(4)
+  if (offset + 80 > data.length) return null;
+
+  const offBmiSrc = view.getUint32(offset + 48, true);
+  const cbBmiSrc = view.getUint32(offset + 52, true);
+  const offBitsSrc = view.getUint32(offset + 56, true);
+  const cbBitsSrc = view.getUint32(offset + 60, true);
+
+  if (cbBmiSrc === 0 || cbBitsSrc === 0) return null;
+
+  const bmiStart = offset + offBmiSrc;
+  if (bmiStart + 40 > data.length) return null;
+
+  // Parse BITMAPINFOHEADER
+  const biWidth = view.getInt32(bmiStart + 4, true);
+  const biHeight = view.getInt32(bmiStart + 8, true);
+  const biBitCount = view.getUint16(bmiStart + 14, true);
+  const biCompression = view.getUint32(bmiStart + 16, true);
+
+  // Only support uncompressed RGB bitmaps
+  if (biCompression !== BI_RGB) return null;
+  if (biBitCount !== 24 && biBitCount !== 32) return null;
+
+  const width = Math.abs(biWidth);
+  const height = Math.abs(biHeight);
+  if (width === 0 || height === 0 || width > 8192 || height > 8192) return null;
+
+  const bitsStart = offset + offBitsSrc;
+  if (bitsStart + cbBitsSrc > data.length) return null;
+
+  const bitsData = data.subarray(bitsStart, bitsStart + cbBitsSrc);
+
+  // Negative height means top-down row order; positive means bottom-up
+  const topDown = biHeight < 0;
+
+  const pixels = new Uint8ClampedArray(width * height * 4);
+  const bytesPerPixel = biBitCount / 8;
+  // DIB rows are padded to 4-byte boundaries
+  const rowStride = Math.ceil((width * bytesPerPixel) / 4) * 4;
+
+  for (let y = 0; y < height; y++) {
+    const srcRow = topDown ? y : height - 1 - y;
+    const srcOffset = srcRow * rowStride;
+    const dstOffset = y * width * 4;
+
+    for (let x = 0; x < width; x++) {
+      const srcIdx = srcOffset + x * bytesPerPixel;
+      if (srcIdx + bytesPerPixel > bitsData.length) break;
+
+      // DIB stores BGR(A)
+      pixels[dstOffset + x * 4 + 0] = bitsData[srcIdx + 2]; // R
+      pixels[dstOffset + x * 4 + 1] = bitsData[srcIdx + 1]; // G
+      pixels[dstOffset + x * 4 + 2] = bitsData[srcIdx + 0]; // B
+      pixels[dstOffset + x * 4 + 3] = biBitCount === 32 ? bitsData[srcIdx + 3] : 255;
+    }
+  }
+
+  return { type: 'bitmap', bitmap: { width, height, data: pixels } };
+}
+
+/**
+ * Find the first occurrence of a byte sequence in a buffer.
+ */
+function findSequence(buf: Uint8Array, seq: number[]): number {
+  const end = buf.length - seq.length;
+  for (let i = 0; i <= end; i++) {
+    if (matchesAt(buf, i, seq)) return i;
+  }
+  return -1;
+}
+
+/**
+ * Check if buffer matches a byte sequence at a given offset.
+ */
+function matchesAt(buf: Uint8Array, offset: number, seq: number[]): boolean {
+  for (let j = 0; j < seq.length; j++) {
+    if (buf[offset + j] !== seq[j]) return false;
+  }
+  return true;
+}

package/src/utils/media.ts

@@ -0,0 +1,73 @@
+/**
+ * Media utilities — MIME type detection, path resolution, and blob URL management.
+ */
+
+/**
+ * Determine MIME type from file extension.
+ * Covers images, video, and audio formats used in PPTX files.
+ */
+export function getMimeType(path: string): string {
+  const ext = path.split('.').pop()?.toLowerCase() || '';
+  const mimeMap: Record<string, string> = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    svg: 'image/svg+xml',
+    bmp: 'image/bmp',
+    tiff: 'image/tiff',
+    tif: 'image/tiff',
+    emf: 'image/x-emf',
+    wmf: 'image/x-wmf',
+    webp: 'image/webp',
+    mp4: 'video/mp4',
+    m4v: 'video/mp4',
+    webm: 'video/webm',
+    avi: 'video/x-msvideo',
+    mp3: 'audio/mpeg',
+    wav: 'audio/wav',
+    m4a: 'audio/mp4',
+    ogg: 'audio/ogg',
+  };
+  return mimeMap[ext] || 'application/octet-stream';
+}
+
+/**
+ * Resolve a relative media path (from rels) to its canonical path in PptxFiles.media.
+ * Rels targets are relative like "../media/image1.png".
+ * Media paths in PptxFiles are like "ppt/media/image1.png".
+ */
+export function resolveMediaPath(target: string): string {
+  const fileName = target.split('/').pop() || '';
+  return `ppt/media/${fileName}`;
+}
+
+/**
+ * Get or create a blob URL for a media file, using a cache to avoid duplicates.
+ *
+ * @param mediaPath - Canonical path (e.g. "ppt/media/image1.png")
+ * @param data - Raw media data (Uint8Array or ArrayBuffer)
+ * @param cache - Map to store/retrieve cached blob URLs
+ * @returns The blob URL string
+ */
+export function getOrCreateBlobUrl(
+  mediaPath: string,
+  data: Uint8Array | ArrayBuffer,
+  cache: Map<string, string>,
+): string {
+  let url = cache.get(mediaPath);
+  if (!url) {
+    const mime = getMimeType(mediaPath);
+    const blob = new Blob([data as unknown as BlobPart], { type: mime });
+    url = URL.createObjectURL(blob);
+    cache.set(mediaPath, url);
+  }
+  return url;
+}
+
+/**
+ * Build a data URL string from raw base64 and MIME.
+ */
+export function toDataUrl(base64: string, mime: string): string {
+  return `data:${mime};base64,${base64}`;
+}

package/src/utils/mediaWebConvert.ts

@@ -0,0 +1,100 @@
+/**
+ * Convert legacy / non-web-safe image bytes (TIFF, EMF bitmap, etc.) to PNG data URLs
+ * so JSON output works in browsers (PPTist). Mirrors pptx-renderer ImageRenderer strategy.
+ */
+
+import UTIF from 'utif';
+import { parseEmfContent } from './emfParser';
+import { rgbaToPngDataUrl } from './rgbaToPng';
+import { getMimeType, toDataUrl } from './media';
+
+type UtifPage = {
+  width: number;
+  height: number;
+  data?: Uint8Array;
+  [key: string]: unknown;
+};
+
+function arrayBufferToBase64(data: Uint8Array): string {
+  let binary = '';
+  const len = data.byteLength;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(data[i]);
+  }
+  if (typeof btoa !== 'undefined') return btoa(binary);
+  const NodeBuffer = (typeof globalThis !== 'undefined' &&
+    (globalThis as unknown as { Buffer?: { from(a: Uint8Array): { toString(e: string): string } } }).Buffer);
+  if (NodeBuffer) return NodeBuffer.from(data).toString('base64');
+  return btoa(binary);
+}
+
+function extOf(path: string): string {
+  return path.split('.').pop()?.toLowerCase() || '';
+}
+
+/**
+ * Decode TIFF/TIF bytes to RGBA using UTIF.
+ */
+function tiffToRgba(data: Uint8Array): { width: number; height: number; data: Uint8ClampedArray } | null {
+  try {
+    const ifds = UTIF.decode(data) as UtifPage[];
+    if (!ifds.length) return null;
+    UTIF.decodeImage(data, ifds[0], ifds);
+    const page = ifds[0];
+    const w = page.width;
+    const h = page.height;
+    if (!w || !h) return null;
+    const rgba = UTIF.toRGBA8(page);
+    return { width: w, height: h, data: new Uint8ClampedArray(rgba) };
+  } catch {
+    return null;
+  }
+}
+
+/** 1×1 transparent PNG — fallback when conversion is not possible */
+const TRANSPARENT_PNG_DATA_URL =
+  'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==';
+
+/**
+ * If the media type is not reliably displayable in browsers, convert to PNG data URL.
+ * Otherwise return `data:<mime>;base64,<raw>` for the original bytes.
+ *
+ * - TIFF/TIF: decode → PNG
+ * - EMF: embedded DIB → PNG; embedded PDF → transparent placeholder (full PDF render needs pdfjs)
+ * - WMF: not supported → transparent placeholder
+ * - PNG/JPEG/GIF/WebP/BMP/SVG: pass through with correct MIME
+ */
+export function encodeMediaForWebDisplay(mediaPath: string, data: Uint8Array): string {
+  const ext = extOf(mediaPath);
+
+  if (ext === 'tif' || ext === 'tiff') {
+    const rgba = tiffToRgba(data);
+    if (rgba) {
+      return rgbaToPngDataUrl(rgba.data, rgba.width, rgba.height);
+    }
+    return TRANSPARENT_PNG_DATA_URL;
+  }
+
+  if (ext === 'emf') {
+    const content = parseEmfContent(data);
+    if (content.type === 'bitmap' && content.bitmap) {
+      const { width, height, data: rgba } = content.bitmap;
+      return rgbaToPngDataUrl(rgba, width, height);
+    }
+    if (content.type === 'pdf') {
+      // Optional: integrate pdfjs-dist later (see pptx-renderer pdfRenderer.ts)
+      return TRANSPARENT_PNG_DATA_URL;
+    }
+    if (content.type === 'empty') {
+      return TRANSPARENT_PNG_DATA_URL;
+    }
+    return TRANSPARENT_PNG_DATA_URL;
+  }
+
+  if (ext === 'wmf') {
+    return TRANSPARENT_PNG_DATA_URL;
+  }
+
+  const mime = getMimeType(mediaPath);
+  return toDataUrl(arrayBufferToBase64(data), mime);
+}

package/src/utils/rgbaToPng.ts

@@ -0,0 +1,33 @@
+/**
+ * Encode RGBA pixel buffer to PNG data URL (browser + Node).
+ */
+
+import { PNG } from 'pngjs';
+
+function uint8ToBase64(u8: Uint8Array): string {
+  let binary = '';
+  for (let i = 0; i < u8.length; i++) {
+    binary += String.fromCharCode(u8[i]);
+  }
+  if (typeof btoa !== 'undefined') return btoa(binary);
+  const NodeBuffer = (typeof globalThis !== 'undefined' &&
+    (globalThis as unknown as { Buffer?: { from(a: Uint8Array): { toString(e: string): string } } }).Buffer);
+  if (NodeBuffer) return NodeBuffer.from(u8).toString('base64');
+  return btoa(binary);
+}
+
+/**
+ * Encode RGBA (length = width * height * 4) to PNG data URL.
+ */
+export function rgbaToPngDataUrl(
+  rgba: Uint8Array | Uint8ClampedArray,
+  width: number,
+  height: number,
+): string {
+  const png = new PNG({ width, height });
+  png.data.set(rgba);
+  const buf = PNG.sync.write(png) as unknown as Uint8Array;
+  const u8 = buf instanceof Uint8Array ? buf : new Uint8Array(buf as ArrayLike<number>);
+  const b64 = uint8ToBase64(u8);
+  return `data:image/png;base64,${b64}`;
+}

package/src/utils/urlSafety.ts

@@ -0,0 +1,17 @@
+/**
+ * URL safety utilities for external hyperlinks/media in untrusted PPTX content.
+ */
+
+const ALLOWED_PROTOCOLS = new Set(['http:', 'https:', 'mailto:']);
+
+/**
+ * Returns true only for absolute URLs with an allowed protocol.
+ */
+export function isAllowedExternalUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    return ALLOWED_PROTOCOLS.has(parsed.protocol.toLowerCase());
+  } catch {
+    return false;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "src1"]
+}