pptx-react-viewer 1.0.0

package/node_modules/pptx-viewer-core/dist/converter/index.js

@@ -0,0 +1,3676 @@
+'use strict';
+
+// src/converter/media-context.ts
+var MIME_TO_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/gif": "gif",
+  "image/svg+xml": "svg",
+  "image/webp": "webp",
+  "image/bmp": "bmp",
+  "image/tiff": "tiff"
+};
+function mimeSubtypeToExt(mime) {
+  const parts = mime.split("/");
+  if (parts.length === 2) {
+    return parts[1].replace(/[^a-z0-9]/g, "");
+  }
+  return "bin";
+}
+function dataUrlToMediaBytes(dataUrl) {
+  const match = dataUrl.match(/^data:([^;]+);base64,(.+)$/s);
+  if (!match) {
+    throw new Error("Invalid data URL format");
+  }
+  const mime = match[1].toLowerCase();
+  const ext = MIME_TO_EXT[mime] ?? mimeSubtypeToExt(mime);
+  const base64 = match[2];
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return { bytes, ext };
+}
+function generateMediaFilename(index, ext) {
+  const padded = String(index).padStart(3, "0");
+  const cleanExt = ext.startsWith(".") ? ext.slice(1) : ext;
+  return `image-${padded}.${cleanExt}`;
+}
+var MediaContext = class {
+  /**
+   * @param outputDir - Root output directory for the conversion.
+   * @param folderName - Sub-folder name for media files (e.g. `"media"`).
+   * @param fs - Optional file system adapter; omit for in-memory-only conversion.
+   */
+  constructor(outputDir, folderName, fs) {
+    this.folderName = folderName;
+    this.fs = fs;
+    this.resolvedMediaDir = `${outputDir}/${this.folderName}`;
+  }
+  /** Running counter used to assign unique sequential filenames. */
+  imageIndex = 0;
+  /** Whether the media output directory has been created yet. */
+  initialized = false;
+  /** Fully resolved path to the media output directory. */
+  resolvedMediaDir;
+  /** Returns the total number of images saved so far in this session. */
+  get totalImages() {
+    return this.imageIndex;
+  }
+  /** Returns the absolute path to the media output directory. */
+  get mediaDir() {
+    return this.resolvedMediaDir;
+  }
+  /**
+   * Decodes a Base64 `data:` URL, saves the image to disk (if a FS adapter
+   * is available), and returns a relative path suitable for embedding in markdown.
+   *
+   * @param dataUrl - The Base64-encoded data URL of the image.
+   * @param prefix - Optional filename prefix (e.g. `"slide3"`) for disambiguation.
+   * @returns A relative path like `"./media/slide3-image-001.png"`.
+   * @throws Error if the data URL is malformed.
+   */
+  async saveImage(dataUrl, prefix) {
+    const decoded = dataUrlToMediaBytes(dataUrl);
+    return this.saveImageBytes(decoded.bytes, decoded.ext, prefix);
+  }
+  /**
+   * Saves raw image bytes to disk and returns a relative path for markdown embedding.
+   *
+   * @param bytes - Raw binary content of the image.
+   * @param ext - File extension (e.g. `"png"`, `"jpg"`).
+   * @param prefix - Optional filename prefix for disambiguation.
+   * @returns A relative path like `"./media/image-001.png"`.
+   */
+  async saveImageBytes(bytes, ext, prefix) {
+    await this.ensureInitialized();
+    this.imageIndex += 1;
+    const baseName = generateMediaFilename(this.imageIndex, ext);
+    const filename = prefix ? `${prefix}-${baseName}` : baseName;
+    if (this.fs) {
+      const filePath = `${this.resolvedMediaDir}/${filename}`;
+      await this.fs.writeBinaryFile(filePath, bytes);
+    }
+    return `./${this.folderName}/${filename}`;
+  }
+  /**
+   * Lazily creates the media output directory on the first call.
+   * Subsequent calls are no-ops.
+   */
+  async ensureInitialized() {
+    if (this.initialized) {
+      return;
+    }
+    if (this.fs) {
+      await this.fs.createFolder(this.resolvedMediaDir);
+    }
+    this.initialized = true;
+  }
+};
+
+// src/converter/base.ts
+function normalizePath(pathValue) {
+  return pathValue.trim().replace(/\\/g, "/");
+}
+function getDirectory(filePath) {
+  const normalized = normalizePath(filePath);
+  const index = normalized.lastIndexOf("/");
+  if (index < 0) {
+    return ".";
+  }
+  if (index === 0) {
+    return "/";
+  }
+  return normalized.slice(0, index);
+}
+function deriveOutputPath(sourcePath, explicitPath) {
+  if (explicitPath) {
+    return explicitPath;
+  }
+  if (!sourcePath) {
+    return void 0;
+  }
+  const normalized = normalizePath(sourcePath);
+  const dotIndex = normalized.lastIndexOf(".");
+  if (dotIndex < 0) {
+    return `${normalized}.md`;
+  }
+  return `${normalized.slice(0, dotIndex)}.md`;
+}
+var DocumentConverter = class {
+  /**
+   * @param outputDir - Root directory for all output files (markdown + media).
+   * @param options - Conversion options (output path, media folder name, metadata flag).
+   * @param fs - Optional file system adapter for writing files to disk.
+   */
+  constructor(outputDir, options, fs) {
+    this.outputDir = outputDir;
+    this.options = options;
+    this.fs = fs;
+    this.mediaContext = new MediaContext(outputDir, options.mediaFolderName, fs);
+  }
+  /** Shared context for extracting and saving media (images) during conversion. */
+  mediaContext;
+  /**
+   * Builds a YAML front-matter block from a key-value metadata dictionary.
+   * String values are quoted; numeric values are emitted bare.
+   *
+   * @param metadata - Key-value pairs to include in the front matter.
+   * @returns A complete front-matter string (including `---` delimiters and trailing blank lines).
+   */
+  buildFrontMatter(metadata) {
+    const lines = ["---"];
+    for (const [key, value] of Object.entries(metadata)) {
+      if (typeof value === "string") {
+        lines.push(`${key}: "${value}"`);
+      } else {
+        lines.push(`${key}: ${value}`);
+      }
+    }
+    lines.push("---", "", "");
+    return lines.join("\n");
+  }
+  /**
+   * Writes the generated markdown content to an output file using the
+   * configured {@link FileSystemAdapter}.
+   *
+   * @param content - The markdown string to write.
+   * @param outputPath - Destination file path.
+   * @throws Error if no `FileSystemAdapter` was provided at construction time.
+   */
+  async writeOutput(content, outputPath) {
+    if (!this.fs) {
+      throw new Error(
+        "FileSystemAdapter is required for writing output files. Provide one via the constructor or use convert() without outputPath."
+      );
+    }
+    await this.fs.writeFile(outputPath, content);
+  }
+};
+
+// src/converter/elements/ChartElementProcessor.ts
+var ChartElementProcessor = class {
+  supportedTypes = ["chart"];
+  async process(element, _ctx) {
+    if (element.type !== "chart") {
+      return null;
+    }
+    const chartElement = element;
+    const chartData = chartElement.chartData;
+    if (!chartData) {
+      return "*[Chart: no data]*";
+    }
+    const output = [];
+    const title = chartData.title?.trim() || "Untitled Chart";
+    const chartType = this.humanizeType(chartData.chartType);
+    output.push(`**${title}**`);
+    output.push(`*Type: ${chartType}*`);
+    const axisInfo = this.renderAxes(chartData.axes);
+    if (axisInfo) {
+      output.push(axisInfo);
+    }
+    const isPie = chartData.chartType === "pie" || chartData.chartType === "pie3D" || chartData.chartType === "doughnut";
+    if (chartData.categories.length > 0 && chartData.series.length > 0) {
+      output.push(this.renderDataTable(chartData.categories, chartData.series, isPie));
+    } else if (chartData.series.length > 0) {
+      for (const series of chartData.series) {
+        const values = series.values.map((value) => String(value)).join(", ");
+        output.push(`- **${series.name}**: ${values}`);
+      }
+    }
+    const dataLabels = this.renderDataLabels(chartData.series);
+    if (dataLabels) {
+      output.push(dataLabels);
+    }
+    const errBars = this.renderErrorBars(chartData.series);
+    if (errBars) {
+      output.push(errBars);
+    }
+    if (chartData.grouping) {
+      output.push(`*Grouping: ${chartData.grouping}*`);
+    }
+    if (chartData.style?.legendPosition) {
+      output.push(`*Legend: ${chartData.style.legendPosition}*`);
+    }
+    if (chartData.dataTable) {
+      const flags = [];
+      if (chartData.dataTable.showHorzBorder) {
+        flags.push("horizontal borders");
+      }
+      if (chartData.dataTable.showVertBorder) {
+        flags.push("vertical borders");
+      }
+      if (chartData.dataTable.showOutline) {
+        flags.push("outline");
+      }
+      if (chartData.dataTable.showKeys) {
+        flags.push("keys");
+      }
+      if (flags.length > 0) {
+        output.push(`*Data table: ${flags.join(", ")}*`);
+      }
+    }
+    const trendlines = chartData.series.flatMap(
+      (series) => (series.trendlines ?? []).map((trendline) => `${series.name} (${trendline.trendlineType})`)
+    );
+    if (trendlines.length > 0) {
+      output.push(`*Trendlines: ${trendlines.join(", ")}*`);
+    }
+    if (chartData.externalData?.targetPath) {
+      output.push(`*External data: ${chartData.externalData.targetPath}*`);
+    }
+    return output.join("\n\n");
+  }
+  renderAxes(axes) {
+    if (!axes || axes.length === 0) {
+      return null;
+    }
+    const parts = [];
+    for (const axis of axes) {
+      const label = this.humanizeAxisType(axis.axisType);
+      const details = [];
+      if (axis.titleText) {
+        details.push(`"${axis.titleText}"`);
+      }
+      if (axis.numFmt?.formatCode) {
+        details.push(`format: ${axis.numFmt.formatCode}`);
+      }
+      if (details.length > 0) {
+        parts.push(`${label}: ${details.join(", ")}`);
+      }
+    }
+    if (parts.length === 0) {
+      return null;
+    }
+    return `*Axes: ${parts.join(" | ")}*`;
+  }
+  humanizeAxisType(axisType) {
+    switch (axisType) {
+      case "catAx":
+        return "Category";
+      case "valAx":
+        return "Value";
+      case "dateAx":
+        return "Date";
+      case "serAx":
+        return "Series";
+      default:
+        return axisType;
+    }
+  }
+  renderDataLabels(series) {
+    const labels = [];
+    for (const s of series) {
+      if (!s.dataLabels || s.dataLabels.length === 0) {
+        continue;
+      }
+      for (const dl of s.dataLabels) {
+        const desc = this.describeDataLabel(dl, s.name);
+        if (desc) {
+          labels.push(desc);
+        }
+      }
+    }
+    if (labels.length === 0) {
+      return null;
+    }
+    return `*Data labels: ${labels.join("; ")}*`;
+  }
+  describeDataLabel(dl, seriesName) {
+    if (dl.text) {
+      return `${seriesName}[${dl.idx}]: "${dl.text}"`;
+    }
+    const flags = [];
+    if (dl.showVal) {
+      flags.push("value");
+    }
+    if (dl.showCatName) {
+      flags.push("category");
+    }
+    if (dl.showSerName) {
+      flags.push("series");
+    }
+    if (dl.showPercent) {
+      flags.push("percent");
+    }
+    if (flags.length === 0) {
+      return null;
+    }
+    return `${seriesName}[${dl.idx}]: ${flags.join("+")}`;
+  }
+  renderErrorBars(series) {
+    const bars = [];
+    for (const s of series) {
+      if (!s.errBars || s.errBars.length === 0) {
+        continue;
+      }
+      for (const eb of s.errBars) {
+        bars.push(this.describeErrorBar(eb, s.name));
+      }
+    }
+    if (bars.length === 0) {
+      return null;
+    }
+    return `*Error bars: ${bars.join("; ")}*`;
+  }
+  describeErrorBar(eb, seriesName) {
+    const valDesc = eb.val !== void 0 ? ` ${eb.val}` : "";
+    return `${seriesName} ${eb.direction}-axis ${eb.valType}${valDesc} (${eb.barType})`;
+  }
+  renderDataTable(categories, series, includePctColumn) {
+    const totalForPct = includePctColumn ? this.computeSeriesTotal(series) : 0;
+    const showPct = includePctColumn && totalForPct > 0;
+    const headers = ["Category", ...series.map((entry) => entry.name)];
+    if (showPct) {
+      headers.push("%");
+    }
+    const widths = headers.map((header) => Math.max(3, header.length));
+    for (let rowIndex = 0; rowIndex < categories.length; rowIndex += 1) {
+      widths[0] = Math.max(widths[0], categories[rowIndex]?.length ?? 0);
+      for (let seriesIndex = 0; seriesIndex < series.length; seriesIndex += 1) {
+        const value = String(series[seriesIndex].values[rowIndex] ?? "");
+        widths[seriesIndex + 1] = Math.max(widths[seriesIndex + 1], value.length);
+      }
+      if (showPct) {
+        const pct = this.computeRowPct(series, rowIndex, totalForPct);
+        widths[widths.length - 1] = Math.max(widths[widths.length - 1], pct.length);
+      }
+    }
+    const formatRow = (cells) => {
+      const padded = cells.map((cell, index) => cell.padEnd(widths[index]));
+      return `| ${padded.join(" | ")} |`;
+    };
+    const separator = `| ${widths.map((width) => "-".repeat(width)).join(" | ")} |`;
+    const rows = categories.map((category, rowIndex) => {
+      const row = [category, ...series.map((entry) => String(entry.values[rowIndex] ?? ""))];
+      if (showPct) {
+        row.push(this.computeRowPct(series, rowIndex, totalForPct));
+      }
+      return formatRow(row);
+    });
+    return [formatRow(headers), separator, ...rows].join("\n");
+  }
+  computeSeriesTotal(series) {
+    let total = 0;
+    for (const s of series) {
+      for (const v of s.values) {
+        total += Math.abs(v ?? 0);
+      }
+    }
+    return total;
+  }
+  computeRowPct(series, rowIndex, total) {
+    let rowSum = 0;
+    for (const s of series) {
+      rowSum += Math.abs(s.values[rowIndex] ?? 0);
+    }
+    if (total === 0) {
+      return "0.0%";
+    }
+    return `${(rowSum / total * 100).toFixed(1)}%`;
+  }
+  humanizeType(value) {
+    return value.replace(/([a-z])([A-Z0-9])/g, "$1 $2").replace(/^./, (char) => char.toUpperCase());
+  }
+};
+
+// src/converter/elements/ElementProcessor.ts
+var ElementProcessorRegistry = class {
+  processors = /* @__PURE__ */ new Map();
+  register(processor) {
+    for (const type of processor.supportedTypes) {
+      this.processors.set(type, processor);
+    }
+  }
+  getProcessor(type) {
+    return this.processors.get(type) ?? null;
+  }
+  async processElement(element, ctx) {
+    const processor = this.getProcessor(element.type);
+    if (!processor) {
+      return null;
+    }
+    let result = await processor.process(element, ctx);
+    if (result === null) {
+      return null;
+    }
+    const base = element;
+    if (base.hidden) {
+      result = `*[Hidden]* ${result}`;
+    }
+    result += this.buildActionAnnotation(base.actionClick, "Click");
+    result += this.buildActionAnnotation(base.actionHover, "Hover");
+    return result;
+  }
+  buildActionAnnotation(action, _trigger) {
+    if (!action) {
+      return "";
+    }
+    if (action.url) {
+      const linkText = action.tooltip ?? action.url;
+      return `
+
+[${linkText}](${action.url})`;
+    }
+    if (action.targetSlideIndex !== void 0) {
+      const label = `Jump to slide ${action.targetSlideIndex + 1}`;
+      return `
+
+*${label}*`;
+    }
+    if (action.action) {
+      return `
+
+*${action.action}*`;
+    }
+    return "";
+  }
+};
+
+// src/converter/elements/FallbackElementProcessor.ts
+var FallbackElementProcessor = class {
+  supportedTypes = ["zoom", "contentPart", "unknown"];
+  async process(element, ctx) {
+    if (element.type === "zoom") {
+      return this.renderZoom(element, ctx);
+    }
+    if (element.type === "contentPart") {
+      return this.renderContentPart(element);
+    }
+    if (element.type === "unknown") {
+      return "*[Unsupported Element]*";
+    }
+    return null;
+  }
+  async renderZoom(zoomElement, ctx) {
+    const slideNumber = zoomElement.targetSlideIndex + 1;
+    const parts = [];
+    if (zoomElement.zoomType === "section") {
+      if (zoomElement.targetSectionId) {
+        parts.push(`*[Zoom to Section ${zoomElement.targetSectionId} (Slide ${slideNumber})]*`);
+      } else {
+        parts.push(`*[Zoom to Section (Slide ${slideNumber})]*`);
+      }
+    } else {
+      parts.push(`*[Zoom to Slide ${slideNumber}]*`);
+    }
+    const imagePath = await this.extractZoomImage(zoomElement, ctx);
+    if (imagePath) {
+      const alt = zoomElement.altText?.trim() || `Zoom preview slide ${slideNumber}`;
+      parts.push(`![${alt}](${imagePath})`);
+    }
+    return parts.join("\n\n");
+  }
+  async extractZoomImage(zoomElement, ctx) {
+    const dataUrl = zoomElement.imageData ?? zoomElement.svgData;
+    if (!dataUrl || !dataUrl.startsWith("data:")) {
+      return null;
+    }
+    try {
+      return await ctx.mediaContext.saveImage(dataUrl, `slide${ctx.slideNumber}-zoom`);
+    } catch {
+      return null;
+    }
+  }
+  renderContentPart(contentPart) {
+    if (contentPart.inkStrokes && contentPart.inkStrokes.length > 0) {
+      return `*[Ink Content: ${contentPart.inkStrokes.length} stroke${contentPart.inkStrokes.length === 1 ? "" : "s"}]*`;
+    }
+    return "*[Content Part]*";
+  }
+};
+
+// src/converter/elements/GroupElementProcessor.ts
+var GroupElementProcessor = class {
+  supportedTypes = ["group"];
+  async process(element, ctx) {
+    if (element.type !== "group") {
+      return null;
+    }
+    const groupElement = element;
+    if (groupElement.children.length === 0) {
+      return null;
+    }
+    const children = await ctx.processElements(groupElement.children);
+    if (children.length === 0) {
+      return null;
+    }
+    return children.join("\n\n");
+  }
+};
+
+// src/core/types/type-guards.ts
+function isImageLikeElement(element) {
+  return element.type === "image" || element.type === "picture";
+}
+function hasTextProperties(element) {
+  return element.type === "text" || element.type === "shape" || element.type === "connector";
+}
+
+// src/converter/elements/ImageElementProcessor.ts
+var ImageElementProcessor = class {
+  supportedTypes = ["image", "picture"];
+  async process(element, ctx) {
+    if (!isImageLikeElement(element)) {
+      return null;
+    }
+    const imageElement = element;
+    const altText = this.sanitiseAltText(imageElement.altText);
+    const imagePath = await this.extractImage(imageElement, ctx);
+    if (!imagePath) {
+      const hasData = Boolean(imageElement.imageData);
+      const dataPreview = imageElement.imageData ? imageElement.imageData.substring(0, 80) : "undefined";
+      const msg = `Image extraction failed on slide ${ctx.slideNumber}: id="${imageElement.id}", imagePath="${imageElement.imagePath ?? "unknown"}", hasImageData=${hasData}, imageDataPreview="${dataPreview}", hasSvgData=${Boolean(imageElement.svgData)}`;
+      console.error(`[image-processor] ${msg}`);
+      return `> **[Image extraction failed]** ${imageElement.id} (slide ${ctx.slideNumber})`;
+    }
+    if (ctx.semanticMode) {
+      return `![${altText}](${imagePath})`;
+    }
+    if (ctx.layoutScale) {
+      return `<img src="${imagePath}" alt="${altText}" style="max-width:100%;height:auto">`;
+    }
+    const dims = this.computeDisplaySize(element.width, element.height);
+    return `<img src="${imagePath}" alt="${altText}" width="${dims.w}" height="${dims.h}">`;
+  }
+  /** Scale element dimensions to a sensible display size, capping width. */
+  computeDisplaySize(origW, origH, maxW = 600) {
+    if (origW <= 0 || origH <= 0) {
+      return { w: 100, h: 100 };
+    }
+    if (origW <= maxW) {
+      return { w: Math.round(origW), h: Math.round(origH) };
+    }
+    const scale = maxW / origW;
+    return { w: maxW, h: Math.round(origH * scale) };
+  }
+  async extractImage(imageElement, ctx) {
+    if (imageElement.imageData && imageElement.imageData.startsWith("data:")) {
+      return await ctx.mediaContext.saveImage(imageElement.imageData, `slide${ctx.slideNumber}`);
+    }
+    if (imageElement.svgData && imageElement.svgData.startsWith("data:")) {
+      return await ctx.mediaContext.saveImage(imageElement.svgData, `slide${ctx.slideNumber}`);
+    }
+    return null;
+  }
+  /** Clean and truncate image alt text for readable markdown output. */
+  sanitiseAltText(raw) {
+    if (!raw) {
+      return "";
+    }
+    const MAX_ALT_LENGTH = 100;
+    const cleaned = raw.replace(/&#x[0-9A-Fa-f]+;/g, " ").replace(/&#\d+;/g, " ").replace(/&[a-zA-Z]+;/g, " ").replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+    if (cleaned.length <= MAX_ALT_LENGTH) {
+      return cleaned;
+    }
+    return `${cleaned.slice(0, MAX_ALT_LENGTH).trimEnd()}\u2026`;
+  }
+};
+
+// src/converter/elements/InkElementProcessor.ts
+var InkElementProcessor = class {
+  supportedTypes = ["ink"];
+  async process(element, _ctx) {
+    if (element.type !== "ink") {
+      return null;
+    }
+    const inkElement = element;
+    const details = [];
+    const strokeCount = inkElement.inkPaths.length;
+    details.push(`${strokeCount} stroke${strokeCount === 1 ? "" : "s"}`);
+    if (inkElement.inkColors && inkElement.inkColors.length > 0) {
+      const unique = [...new Set(inkElement.inkColors)];
+      if (unique.length <= 4) {
+        details.push(`colors ${unique.join(", ")}`);
+      } else {
+        details.push(`${unique.length} colors`);
+      }
+    }
+    if (inkElement.inkTool) {
+      details.push(`tool ${inkElement.inkTool}`);
+    }
+    if (inkElement.inkOpacities && inkElement.inkOpacities.length > 0) {
+      const avgOpacity = inkElement.inkOpacities.reduce((sum, value) => sum + value, 0) / inkElement.inkOpacities.length;
+      details.push(`opacity ${Math.round(avgOpacity * 100)}%`);
+    }
+    return `*[Ink Drawing: ${details.join(" | ")}]*`;
+  }
+};
+
+// src/converter/elements/MediaElementProcessor.ts
+var MediaElementProcessor = class {
+  supportedTypes = ["media"];
+  async process(element, ctx) {
+    if (element.type !== "media") {
+      return null;
+    }
+    const mediaElement = element;
+    const label = this.resolveLabel(mediaElement);
+    const output = [`*[${label}]*`];
+    const details = this.buildDetails(mediaElement);
+    if (details.length > 0) {
+      output.push(`*${details.join(" | ")}*`);
+    }
+    if (mediaElement.posterFrameData && mediaElement.posterFrameData.startsWith("data:")) {
+      try {
+        const posterPath = await ctx.mediaContext.saveImage(
+          mediaElement.posterFrameData,
+          `slide${ctx.slideNumber}-poster`
+        );
+        output.push(`![${label} poster](${posterPath})`);
+      } catch {
+      }
+    }
+    if (mediaElement.captionTracks && mediaElement.captionTracks.length > 0) {
+      const captions = mediaElement.captionTracks.map((track) => `${track.label} (${track.language})`).join(", ");
+      output.push(`*Captions: ${captions}*`);
+    }
+    if (mediaElement.mediaMissing) {
+      output.push("*Media source is missing*");
+    }
+    return output.join("\n\n");
+  }
+  resolveLabel(mediaElement) {
+    const fileName = mediaElement.mediaPath?.split("/").pop();
+    if (mediaElement.mediaType === "video") {
+      return `Video: ${fileName ?? "embedded media"}`;
+    }
+    if (mediaElement.mediaType === "audio") {
+      return `Audio: ${fileName ?? "embedded media"}`;
+    }
+    return `Media: ${fileName ?? "embedded media"}`;
+  }
+  buildDetails(mediaElement) {
+    const details = [];
+    if (mediaElement.mediaPath) {
+      details.push(`Path: ${mediaElement.mediaPath}`);
+    }
+    if (typeof mediaElement.metadata?.duration === "number") {
+      details.push(`Duration: ${this.formatDuration(mediaElement.metadata.duration)}`);
+    }
+    if (typeof mediaElement.metadata?.videoWidth === "number" && typeof mediaElement.metadata?.videoHeight === "number") {
+      details.push(
+        `Resolution: ${mediaElement.metadata.videoWidth}x${mediaElement.metadata.videoHeight}`
+      );
+    }
+    if (mediaElement.loop) {
+      details.push("Looping");
+    }
+    if (mediaElement.autoPlay) {
+      details.push("Auto-play");
+    }
+    if (mediaElement.playAcrossSlides) {
+      details.push("Plays across slides");
+    }
+    if (mediaElement.mediaMimeType) {
+      details.push(`MIME: ${mediaElement.mediaMimeType}`);
+    }
+    return details;
+  }
+  formatDuration(seconds) {
+    const minutes = Math.floor(seconds / 60);
+    const remainder = Math.round(seconds % 60);
+    return `${minutes}:${String(remainder).padStart(2, "0")}`;
+  }
+};
+
+// src/converter/elements/OleElementProcessor.ts
+var OleElementProcessor = class {
+  supportedTypes = ["ole"];
+  async process(element, ctx) {
+    if (element.type !== "ole") {
+      return null;
+    }
+    const oleElement = element;
+    const objectType = oleElement.oleObjectType ?? "unknown";
+    const fileName = oleElement.fileName ?? oleElement.oleName ?? "embedded-object";
+    const output = [`*[Embedded ${objectType}: ${fileName}]*`];
+    if (oleElement.oleFileExtension) {
+      output.push(`*Extension: .${oleElement.oleFileExtension}*`);
+    }
+    if (oleElement.oleProgId) {
+      output.push(`*Program ID: ${oleElement.oleProgId}*`);
+    }
+    if (oleElement.isLinked) {
+      output.push("*Linked object*");
+    }
+    const previewSource = oleElement.previewImageData ?? oleElement.previewImage;
+    if (previewSource && previewSource.startsWith("data:")) {
+      try {
+        const previewPath = await ctx.mediaContext.saveImage(
+          previewSource,
+          `slide${ctx.slideNumber}-ole`
+        );
+        output.push(`![Embedded ${objectType} preview](${previewPath})`);
+      } catch {
+      }
+    }
+    return output.join("\n\n");
+  }
+};
+
+// src/converter/elements/SmartArtElementProcessor.ts
+var ORDERED_LAYOUTS = /* @__PURE__ */ new Set(["process", "cycle", "timeline"]);
+var NESTED_LAYOUTS = /* @__PURE__ */ new Set(["hierarchy", "pyramid", "funnel"]);
+var BULLET_LAYOUTS = /* @__PURE__ */ new Set(["list", "matrix", "gear", "target"]);
+var SmartArtElementProcessor = class {
+  supportedTypes = ["smartArt"];
+  async process(element, _ctx) {
+    if (element.type !== "smartArt") {
+      return null;
+    }
+    const smartArtData = element.smartArtData;
+    if (!smartArtData || smartArtData.nodes.length === 0) {
+      return "*[SmartArt: no nodes]*";
+    }
+    const roots = this.resolveRoots(smartArtData.nodes);
+    const layoutType = smartArtData.resolvedLayoutType ?? "unknown";
+    const parts = [`*[SmartArt: ${layoutType}]*`];
+    if (NESTED_LAYOUTS.has(layoutType)) {
+      parts.push(this.renderNestedList(roots, 0));
+    } else if (ORDERED_LAYOUTS.has(layoutType)) {
+      parts.push(this.renderOrderedSequence(roots));
+    } else if (BULLET_LAYOUTS.has(layoutType)) {
+      parts.push(this.renderBulletList(roots));
+    } else if (layoutType === "relationship") {
+      parts.push(this.renderRelationshipText(roots));
+    } else {
+      parts.push(this.renderBulletList(roots));
+    }
+    return parts.join("\n\n");
+  }
+  resolveRoots(nodes) {
+    if (nodes.some((node) => Array.isArray(node.children) && node.children.length > 0)) {
+      return nodes;
+    }
+    const nodeMap = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      nodeMap.set(node.id, { ...node, children: [] });
+    }
+    const roots = [];
+    for (const node of nodeMap.values()) {
+      if (node.parentId && nodeMap.has(node.parentId)) {
+        nodeMap.get(node.parentId)?.children?.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+    return roots.length > 0 ? roots : [...nodeMap.values()];
+  }
+  renderNestedList(nodes, level) {
+    const lines = [];
+    const indent = "  ".repeat(level);
+    for (const node of nodes) {
+      const text = node.text.trim();
+      if (text) {
+        lines.push(`${indent}- ${text}`);
+      }
+      if (node.children && node.children.length > 0) {
+        lines.push(this.renderNestedList(node.children, level + 1));
+      }
+    }
+    return lines.join("\n");
+  }
+  renderOrderedSequence(nodes) {
+    const flattened = this.flattenNodes(nodes).map((node) => node.text.trim()).filter((text) => text.length > 0);
+    const lines = [];
+    for (let index = 0; index < flattened.length; index += 1) {
+      lines.push(`${index + 1}. ${flattened[index]}`);
+    }
+    return lines.join("\n");
+  }
+  renderBulletList(nodes) {
+    return this.flattenNodes(nodes).map((node) => node.text.trim()).filter((text) => text.length > 0).map((text) => `- ${text}`).join("\n");
+  }
+  renderRelationshipText(nodes) {
+    const entries = this.flattenNodes(nodes).map((node) => node.text.trim()).filter((text) => text.length > 0);
+    if (entries.length === 0) {
+      return "*[SmartArt relationship]*";
+    }
+    if (entries.length === 1) {
+      return entries[0];
+    }
+    return entries.join(" -> ");
+  }
+  flattenNodes(nodes) {
+    const flattened = [];
+    for (const node of nodes) {
+      flattened.push(node);
+      if (node.children && node.children.length > 0) {
+        flattened.push(...this.flattenNodes(node.children));
+      }
+    }
+    return flattened;
+  }
+};
+
+// src/core/utils/font-substitution.ts
+var FONT_SUBSTITUTION_MAP = {
+  // Microsoft Office default fonts
+  Calibri: ["Carlito", "Liberation Sans", "Arial", "sans-serif"],
+  "Calibri Light": ["Carlito", "Liberation Sans", "Arial", "sans-serif"],
+  Cambria: ["Caladea", "Liberation Serif", "Times New Roman", "serif"],
+  "Cambria Math": ["STIX Two Math", "Latin Modern Math", "Times New Roman", "serif"],
+  Consolas: ["Liberation Mono", "Courier New", "monospace"],
+  "Segoe UI": ["Liberation Sans", "Helvetica Neue", "Arial", "sans-serif"],
+  "Segoe UI Light": ["Liberation Sans", "Helvetica Neue", "Arial", "sans-serif"],
+  "Segoe UI Semibold": ["Liberation Sans", "Helvetica Neue", "Arial", "sans-serif"],
+  // Classic Windows fonts → cross-platform equivalents
+  "Times New Roman": ["Liberation Serif", "Times", "serif"],
+  Arial: ["Liberation Sans", "Helvetica", "sans-serif"],
+  "Arial Black": ["Liberation Sans", "Helvetica", "sans-serif"],
+  "Arial Narrow": ["Liberation Sans Narrow", "Helvetica Neue", "sans-serif"],
+  "Courier New": ["Liberation Mono", "Courier", "monospace"],
+  Verdana: ["DejaVu Sans", "Bitstream Vera Sans", "sans-serif"],
+  Georgia: ["Liberation Serif", "Times New Roman", "serif"],
+  Tahoma: ["DejaVu Sans", "Liberation Sans", "sans-serif"],
+  Trebuchet: ["Liberation Sans", "sans-serif"],
+  "Trebuchet MS": ["Liberation Sans", "sans-serif"],
+  "Comic Sans MS": ["Comic Neue", "cursive"],
+  Impact: ["Charcoal", "sans-serif"],
+  "Lucida Console": ["Liberation Mono", "monospace"],
+  "Lucida Sans Unicode": ["Lucida Grande", "Liberation Sans", "sans-serif"],
+  Palatino: ["Palatino Linotype", "Book Antiqua", "serif"],
+  "Palatino Linotype": ["Palatino", "Book Antiqua", "serif"],
+  "Book Antiqua": ["Palatino Linotype", "Palatino", "serif"],
+  // CJK fonts
+  "MS PGothic": ["Noto Sans CJK JP", "Hiragino Sans", "Yu Gothic", "sans-serif"],
+  "MS PMincho": ["Noto Serif CJK JP", "Hiragino Mincho ProN", "Yu Mincho", "serif"],
+  "MS Gothic": ["Noto Sans CJK JP", "Hiragino Sans", "Yu Gothic", "sans-serif"],
+  "MS Mincho": ["Noto Serif CJK JP", "Hiragino Mincho ProN", "Yu Mincho", "serif"],
+  SimSun: ["Noto Serif CJK SC", "STSong", "serif"],
+  SimHei: ["Noto Sans CJK SC", "STHeiti", "sans-serif"],
+  "Microsoft YaHei": ["Noto Sans CJK SC", "PingFang SC", "sans-serif"],
+  NSimSun: ["Noto Serif CJK SC", "STSong", "serif"],
+  FangSong: ["Noto Serif CJK SC", "STFangsong", "serif"],
+  KaiTi: ["Noto Serif CJK SC", "STKaiti", "serif"],
+  Batang: ["Noto Serif CJK KR", "AppleMyungjo", "serif"],
+  Dotum: ["Noto Sans CJK KR", "AppleGothic", "sans-serif"],
+  Gulim: ["Noto Sans CJK KR", "AppleGothic", "sans-serif"],
+  Malgun: ["Noto Sans CJK KR", "Apple SD Gothic Neo", "sans-serif"],
+  "Malgun Gothic": ["Noto Sans CJK KR", "Apple SD Gothic Neo", "sans-serif"],
+  // Complex script fonts
+  "Arabic Typesetting": ["Noto Naskh Arabic", "serif"],
+  "Simplified Arabic": ["Noto Sans Arabic", "sans-serif"],
+  "Traditional Arabic": ["Noto Naskh Arabic", "serif"],
+  Mangal: ["Noto Sans Devanagari", "sans-serif"],
+  Vrinda: ["Noto Sans Bengali", "sans-serif"],
+  Raavi: ["Noto Sans Gurmukhi", "sans-serif"],
+  Shruti: ["Noto Sans Gujarati", "sans-serif"],
+  Tunga: ["Noto Sans Kannada", "sans-serif"],
+  Kartika: ["Noto Sans Malayalam", "sans-serif"],
+  Iskoola: ["Noto Sans Sinhala", "sans-serif"],
+  "Iskoola Pota": ["Noto Sans Sinhala", "sans-serif"],
+  Leelawadee: ["Noto Sans Thai", "sans-serif"],
+  "Leelawadee UI": ["Noto Sans Thai", "sans-serif"],
+  "Cordia New": ["Noto Sans Thai", "sans-serif"],
+  DokChampa: ["Noto Sans Lao", "sans-serif"],
+  Nyala: ["Noto Sans Ethiopic", "sans-serif"],
+  MoolBoran: ["Noto Sans Khmer", "sans-serif"],
+  // Decorative / Display
+  "Century Gothic": ["URW Gothic", "Futura", "sans-serif"],
+  "Franklin Gothic": ["Liberation Sans", "Helvetica Neue", "sans-serif"],
+  "Franklin Gothic Medium": ["Liberation Sans", "Helvetica Neue", "sans-serif"],
+  Garamond: ["EB Garamond", "Cormorant Garamond", "serif"],
+  "Tw Cen MT": ["Century Gothic", "Futura", "sans-serif"],
+  Rockwell: ["Roboto Slab", "Rockwell", "serif"],
+  Candara: ["Liberation Sans", "Optima", "sans-serif"],
+  Constantia: ["Liberation Serif", "Palatino", "serif"],
+  Corbel: ["Liberation Sans", "Lucida Grande", "sans-serif"]
+};
+function getSubstituteFontFamily(fontName, panose) {
+  const trimmed = fontName.trim();
+  if (!trimmed) {
+    return "sans-serif";
+  }
+  const directSubs = FONT_SUBSTITUTION_MAP[trimmed];
+  if (directSubs) {
+    return buildFontFamilyString(trimmed, directSubs);
+  }
+  return buildFontFamilyString(trimmed, ["sans-serif"]);
+}
+var CSS_GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "math",
+  "emoji",
+  "fangsong"
+]);
+function buildFontFamilyString(primary, fallbacks) {
+  const parts = [quoteFontName(primary)];
+  for (const fb of fallbacks) {
+    const quoted = quoteFontName(fb);
+    if (!parts.includes(quoted)) {
+      parts.push(quoted);
+    }
+  }
+  return parts.join(", ");
+}
+function quoteFontName(name) {
+  const trimmed = name.trim();
+  if (CSS_GENERIC_FAMILIES.has(trimmed.toLowerCase())) {
+    return trimmed;
+  }
+  return `"${trimmed}"`;
+}
+
+// src/converter/elements/TableElementProcessor.ts
+var TableElementProcessor = class {
+  supportedTypes = ["table"];
+  async process(element, ctx) {
+    if (element.type !== "table") {
+      return null;
+    }
+    const tableElement = element;
+    const tableData = tableElement.tableData;
+    if (!tableData || tableData.rows.length === 0) {
+      return null;
+    }
+    if (ctx.semanticMode && this.canRenderAsMarkdownTable(tableData)) {
+      return this.renderMarkdownTable(tableData);
+    }
+    const rowSpanOccupancy = /* @__PURE__ */ new Map();
+    const htmlRows = [];
+    for (let ri = 0; ri < tableData.rows.length; ri++) {
+      const row = tableData.rows[ri];
+      const isHeader = ri === 0 && tableData.firstRowHeader !== false;
+      const tag = isHeader ? "th" : "td";
+      const cells = [];
+      let ci = 0;
+      for (const cell of row.cells) {
+        while (this.isOccupied(rowSpanOccupancy, ri, ci)) {
+          ci++;
+        }
+        const gridSpan = Math.max(1, cell.gridSpan ?? 1);
+        if (cell.vMerge || cell.hMerge) {
+          ci += gridSpan;
+          continue;
+        }
+        const rowSpan = Math.max(1, cell.rowSpan ?? 1);
+        if (rowSpan > 1) {
+          for (let ro = 1; ro < rowSpan; ro++) {
+            for (let s = 0; s < gridSpan; s++) {
+              this.markOccupied(rowSpanOccupancy, ri + ro, ci + s);
+            }
+          }
+        }
+        const attrs2 = this.buildCellAttrs(cell, gridSpan, rowSpan, isHeader);
+        const content = this.renderCellContent(cell);
+        cells.push(`<${tag}${attrs2}>${content}</${tag}>`);
+        ci += gridSpan;
+      }
+      if (cells.length > 0) {
+        htmlRows.push(`<tr>${cells.join("")}</tr>`);
+      }
+    }
+    if (htmlRows.length === 0) {
+      return null;
+    }
+    return `<table>
+${htmlRows.join("\n")}
+</table>`;
+  }
+  /** Builds inline-style + colspan/rowspan attributes for a cell. */
+  buildCellAttrs(cell, gridSpan, rowSpan, isHeader) {
+    const parts = [];
+    if (gridSpan > 1) {
+      parts.push(` colspan="${gridSpan}"`);
+    }
+    if (rowSpan > 1) {
+      parts.push(` rowspan="${rowSpan}"`);
+    }
+    const css = this.buildCellCss(cell.style, isHeader);
+    if (css) {
+      parts.push(` style="${css}"`);
+    }
+    return parts.join("");
+  }
+  /** Converts PptxTableCellStyle to an inline CSS string. */
+  buildCellCss(style, isHeader) {
+    const rules = [];
+    if (style?.backgroundColor) {
+      rules.push(`background:${style.backgroundColor}`);
+    }
+    if (style?.align) {
+      rules.push(`text-align:${style.align}`);
+    }
+    if (style?.vAlign) {
+      rules.push(`vertical-align:${style.vAlign}`);
+    }
+    if (style?.fontSize) {
+      rules.push(`font-size:${Math.round(style.fontSize)}px`);
+    }
+    if (style?.color) {
+      rules.push(`color:${style.color}`);
+    }
+    if (style?.bold || isHeader) {
+      rules.push("font-weight:bold");
+    }
+    if (style?.italic) {
+      rules.push("font-style:italic");
+    }
+    const border = this.buildBorderCss(style);
+    if (border) {
+      rules.push(border);
+    }
+    const padding = this.buildPaddingCss(style);
+    if (padding) {
+      rules.push(padding);
+    }
+    return rules.join(";");
+  }
+  /** Builds per-edge border CSS from cell style. */
+  buildBorderCss(style) {
+    if (!style) {
+      return "";
+    }
+    const edges = [];
+    if (style.borderTopWidth && style.borderTopColor) {
+      edges.push(`border-top:${style.borderTopWidth}px solid ${style.borderTopColor}`);
+    }
+    if (style.borderBottomWidth && style.borderBottomColor) {
+      edges.push(`border-bottom:${style.borderBottomWidth}px solid ${style.borderBottomColor}`);
+    }
+    if (style.borderLeftWidth && style.borderLeftColor) {
+      edges.push(`border-left:${style.borderLeftWidth}px solid ${style.borderLeftColor}`);
+    }
+    if (style.borderRightWidth && style.borderRightColor) {
+      edges.push(`border-right:${style.borderRightWidth}px solid ${style.borderRightColor}`);
+    }
+    if (edges.length === 0 && style.borderColor) {
+      return `border:1px solid ${style.borderColor}`;
+    }
+    return edges.join(";");
+  }
+  /** Builds padding CSS from cell margin values. */
+  buildPaddingCss(style) {
+    if (!style) {
+      return "";
+    }
+    const t = style.marginTop ?? 0;
+    const r = style.marginRight ?? 0;
+    const b = style.marginBottom ?? 0;
+    const l = style.marginLeft ?? 0;
+    if (t === 0 && r === 0 && b === 0 && l === 0) {
+      return "";
+    }
+    return `padding:${t}px ${r}px ${b}px ${l}px`;
+  }
+  /**
+   * Renders cell content as HTML spans preserving per-run styling
+   * (font-family, font-size, color, bold, italic).
+   */
+  renderCellContent(cell) {
+    const segments = this.getCellSegments(cell);
+    if (segments.length === 0) {
+      return this.escapeHtml(cell.text ?? "");
+    }
+    const parts = [];
+    for (const seg of segments) {
+      if (seg.isParagraphBreak) {
+        parts.push("<br>");
+        continue;
+      }
+      const text = this.escapeHtml(seg.text);
+      if (!text) {
+        continue;
+      }
+      const css = this.buildRunCss(seg, cell.style);
+      if (css) {
+        parts.push(`<span style="${css}">${text}</span>`);
+      } else {
+        parts.push(text);
+      }
+    }
+    return parts.join("");
+  }
+  /** Builds inline CSS for a single text run, only for properties that
+   *  differ from the cell-level defaults. */
+  buildRunCss(seg, cellStyle) {
+    const s = seg.style;
+    const rules = [];
+    if (s.fontFamily) {
+      rules.push(`font-family:${getSubstituteFontFamily(s.fontFamily)}`);
+    }
+    if (s.fontSize && s.fontSize !== cellStyle?.fontSize) {
+      rules.push(`font-size:${Math.round(s.fontSize)}px`);
+    }
+    if (s.color && s.color !== cellStyle?.color) {
+      rules.push(`color:${s.color}`);
+    }
+    if (s.bold && !cellStyle?.bold) {
+      rules.push("font-weight:bold");
+    }
+    if (s.italic && !cellStyle?.italic) {
+      rules.push("font-style:italic");
+    }
+    if (s.underline) {
+      rules.push("text-decoration:underline");
+    }
+    if (s.strikethrough) {
+      rules.push("text-decoration:line-through");
+    }
+    return rules.join(";");
+  }
+  /** Extracts typed TextSegment[] from a cell if present. */
+  getCellSegments(cell) {
+    const raw = cell.textSegments;
+    if (!Array.isArray(raw)) {
+      return [];
+    }
+    return raw.filter(
+      (s) => Boolean(s) && typeof s === "object" && typeof s.text === "string"
+    );
+  }
+  escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  markOccupied(occupancy, row, column) {
+    const set = occupancy.get(row) ?? /* @__PURE__ */ new Set();
+    set.add(column);
+    occupancy.set(row, set);
+  }
+  isOccupied(occupancy, row, column) {
+    return occupancy.get(row)?.has(column) ?? false;
+  }
+  /**
+   * Returns true if the table can be rendered as a simple markdown table
+   * (no merged cells, no row spans, no col spans > 1).
+   */
+  canRenderAsMarkdownTable(tableData) {
+    for (const row of tableData.rows) {
+      for (const cell of row.cells) {
+        if (cell.vMerge || cell.hMerge) {
+          return false;
+        }
+        if ((cell.gridSpan ?? 1) > 1) {
+          return false;
+        }
+        if ((cell.rowSpan ?? 1) > 1) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /** Render a simple table as markdown (no merges/spans). */
+  renderMarkdownTable(tableData) {
+    const rows = tableData.rows;
+    if (rows.length === 0) {
+      return "";
+    }
+    const columnCount = Math.max(...rows.map((r) => r.cells.length));
+    const mdRows = [];
+    const hasHeader = tableData.firstRowHeader !== false;
+    for (let ri = 0; ri < rows.length; ri++) {
+      const cells = rows[ri].cells.map((cell) => {
+        const text = this.getCellFormattedText(cell);
+        return this.escapeMarkdownTableCell(text);
+      });
+      while (cells.length < columnCount) {
+        cells.push("");
+      }
+      mdRows.push(`| ${cells.join(" | ")} |`);
+      if (ri === 0 && hasHeader) {
+        const divider = Array.from({ length: columnCount }, () => "---");
+        mdRows.push(`| ${divider.join(" | ")} |`);
+      }
+    }
+    if (!hasHeader) {
+      const emptyHeader = Array.from({ length: columnCount }, () => "");
+      const divider = Array.from({ length: columnCount }, () => "---");
+      mdRows.unshift(`| ${emptyHeader.join(" | ")} |`, `| ${divider.join(" | ")} |`);
+    }
+    return mdRows.join("\n");
+  }
+  /** Gets cell text with basic markdown formatting (bold/italic). */
+  getCellFormattedText(cell) {
+    const segments = this.getCellSegments(cell);
+    if (segments.length === 0) {
+      return cell.text ?? "";
+    }
+    const parts = [];
+    for (const seg of segments) {
+      if (seg.isParagraphBreak) {
+        parts.push(" ");
+        continue;
+      }
+      let text = seg.text;
+      if (!text) {
+        continue;
+      }
+      if (seg.style.bold && seg.style.italic) {
+        text = `***${text}***`;
+      } else if (seg.style.bold) {
+        text = `**${text}**`;
+      } else if (seg.style.italic) {
+        text = `*${text}*`;
+      }
+      if (seg.style.strikethrough) {
+        text = `~~${text}~~`;
+      }
+      if (seg.style.hyperlink) {
+        text = `[${text}](${seg.style.hyperlink})`;
+      }
+      parts.push(text);
+    }
+    return parts.join("").trim();
+  }
+  escapeMarkdownTableCell(text) {
+    return text.replace(/\|/g, "\\|").replace(/\n+/g, " ").trim();
+  }
+};
+
+// src/converter/ShapeTextRenderer.ts
+var DEFAULT_FONT_SIZE = 18;
+var FALLBACK_PAD_FACTOR = 0.06;
+function drawTextSegments(ctx, segments, bodyStyle, w, h, scaleFactor = 1) {
+  const padL = bodyStyle?.bodyInsetLeft ? bodyStyle.bodyInsetLeft * scaleFactor : Math.round(w * FALLBACK_PAD_FACTOR);
+  const padR = bodyStyle?.bodyInsetRight ? bodyStyle.bodyInsetRight * scaleFactor : Math.round(w * FALLBACK_PAD_FACTOR);
+  const padT = bodyStyle?.bodyInsetTop ? bodyStyle.bodyInsetTop * scaleFactor : Math.round(h * FALLBACK_PAD_FACTOR);
+  const padB = bodyStyle?.bodyInsetBottom ? bodyStyle.bodyInsetBottom * scaleFactor : Math.round(h * FALLBACK_PAD_FACTOR);
+  const maxWidth = w - padL - padR;
+  if (maxWidth <= 0) {
+    return;
+  }
+  const paragraphs = splitIntoParagraphs(segments);
+  const lines = layoutParagraphs(ctx, paragraphs, maxWidth, scaleFactor);
+  if (lines.length === 0) {
+    return;
+  }
+  const totalHeight = lines.reduce((sum, l) => sum + l.height * 1.3, 0);
+  const usableH = h - padT - padB;
+  const vAlign = bodyStyle?.vAlign ?? "top";
+  let y;
+  if (vAlign === "middle") {
+    y = padT + (usableH - totalHeight) / 2;
+  } else if (vAlign === "bottom") {
+    y = h - padB - totalHeight;
+  } else {
+    y = padT;
+  }
+  for (const line of lines) {
+    y += line.height;
+    const hAlign = line.align ?? bodyStyle?.align ?? "left";
+    let x;
+    if (hAlign === "center") {
+      x = padL + (maxWidth - line.width) / 2;
+    } else if (hAlign === "right") {
+      x = padL + maxWidth - line.width;
+    } else {
+      x = padL;
+    }
+    for (const run of line.runs) {
+      ctx.font = buildFont(run.style, scaleFactor);
+      ctx.fillStyle = run.style.color ?? "#000000";
+      ctx.fillText(run.text, x, y);
+      x += run.measuredWidth;
+    }
+    y += line.height * 0.3;
+  }
+}
+function splitIntoParagraphs(segments) {
+  const paragraphs = [[]];
+  for (const seg of segments) {
+    if (seg.isParagraphBreak) {
+      paragraphs.push([]);
+    } else if (seg.text) {
+      paragraphs[paragraphs.length - 1].push(seg);
+    }
+  }
+  return paragraphs.filter((p) => p.length > 0);
+}
+function layoutParagraphs(ctx, paragraphs, maxWidth, scaleFactor) {
+  const lines = [];
+  for (const para of paragraphs) {
+    const paraAlign = para[0]?.style?.align;
+    let currentLine = [];
+    let lineWidth = 0;
+    let lineHeight = 0;
+    for (const seg of para) {
+      ctx.font = buildFont(seg.style, scaleFactor);
+      const fontSize = (seg.style.fontSize ?? DEFAULT_FONT_SIZE) * scaleFactor;
+      const segHeight = fontSize * 1.2;
+      const tokens = seg.text.split(/(?<=\s)(?=\S)|(?<=\S)(?=\s)/);
+      for (const raw of tokens) {
+        if (!raw) {
+          continue;
+        }
+        if (/^\s+$/.test(raw)) {
+          if (currentLine.length > 0) {
+            const spaceW = ctx.measureText(raw).width;
+            currentLine.push({
+              text: raw,
+              style: seg.style,
+              measuredWidth: spaceW
+            });
+            lineWidth += spaceW;
+          }
+          continue;
+        }
+        const word = raw;
+        const wordW = ctx.measureText(word).width;
+        if (lineWidth + wordW > maxWidth && currentLine.length > 0) {
+          while (currentLine.length > 0 && /^\s+$/.test(currentLine[currentLine.length - 1].text)) {
+            const removed = currentLine.pop();
+            lineWidth -= removed.measuredWidth;
+          }
+          lines.push({
+            runs: currentLine,
+            width: lineWidth,
+            height: lineHeight,
+            align: paraAlign
+          });
+          currentLine = [];
+          lineWidth = 0;
+          lineHeight = 0;
+        }
+        currentLine.push({
+          text: word,
+          style: seg.style,
+          measuredWidth: wordW
+        });
+        lineWidth += wordW;
+        lineHeight = Math.max(lineHeight, segHeight);
+      }
+    }
+    if (currentLine.length > 0) {
+      lines.push({
+        runs: currentLine,
+        width: lineWidth,
+        height: lineHeight,
+        align: paraAlign
+      });
+    }
+  }
+  return lines;
+}
+function buildFont(style, scaleFactor) {
+  const size = (style.fontSize ?? DEFAULT_FONT_SIZE) * scaleFactor;
+  const weight = style.bold ? "bold" : "normal";
+  const slant = style.italic ? "italic" : "normal";
+  const family = style.fontFamily ? getSubstituteFontFamily(style.fontFamily) : "sans-serif";
+  return `${slant} ${weight} ${size}px ${family}`;
+}
+
+// src/converter/ShapeImageRenderer.ts
+var MAX_DIM = 400;
+var MAX_DIM_TEXT = 800;
+var MIN_DIM = 4;
+function renderShapeToDataUrl(input) {
+  const style = input.shapeStyle;
+  if (!style) {
+    return null;
+  }
+  if (!hasVisibleFill(style) && !hasVisibleStroke(style)) {
+    return null;
+  }
+  let w = Math.round(input.width);
+  let h = Math.round(input.height);
+  if (w < MIN_DIM || h < MIN_DIM) {
+    return null;
+  }
+  const hasText = (input.textSegments?.length ?? 0) > 0;
+  const maxDim = hasText ? MAX_DIM_TEXT : MAX_DIM;
+  let scaleFactor = 1;
+  if (w > maxDim || h > maxDim) {
+    scaleFactor = maxDim / Math.max(w, h);
+    w = Math.round(w * scaleFactor);
+    h = Math.round(h * scaleFactor);
+  }
+  const canvas = createCanvasElement(w, h);
+  if (!canvas) {
+    return null;
+  }
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    return null;
+  }
+  applyFill(ctx, style, w, h);
+  if (input.pathData) {
+    const pw = input.pathWidth ?? w;
+    const ph = input.pathHeight ?? h;
+    const sx = w / (pw || 1);
+    const sy = h / (ph || 1);
+    const path = new Path2D(input.pathData);
+    ctx.save();
+    ctx.scale(sx, sy);
+    ctx.fill(path);
+    if (hasVisibleStroke(style)) {
+      applyStroke(ctx, style);
+      ctx.stroke(path);
+    }
+    ctx.restore();
+  } else {
+    drawPresetShape(ctx, input.shapeType, w, h);
+    ctx.fill();
+    if (hasVisibleStroke(style)) {
+      applyStroke(ctx, style);
+      drawPresetShape(ctx, input.shapeType, w, h);
+      ctx.stroke();
+    }
+  }
+  ctx.globalAlpha = 1;
+  if (input.textSegments?.length) {
+    drawTextSegments(ctx, input.textSegments, input.textStyle, w, h, scaleFactor);
+  }
+  return canvas.toDataURL("image/png");
+}
+function createCanvasElement(w, h) {
+  try {
+    if (typeof document !== "undefined" && document.createElement) {
+      const c = document.createElement("canvas");
+      c.width = w;
+      c.height = h;
+      return c;
+    }
+  } catch {
+  }
+  return null;
+}
+function drawPresetShape(ctx, shapeType, w, h) {
+  ctx.beginPath();
+  const type = shapeType ?? "rect";
+  switch (type) {
+    case "ellipse":
+      ctx.ellipse(w / 2, h / 2, w / 2, h / 2, 0, 0, Math.PI * 2);
+      break;
+    case "roundRect": {
+      const r = Math.min(w, h) * 0.1;
+      roundRect(ctx, 0, 0, w, h, r);
+      break;
+    }
+    case "triangle":
+    case "flowChartProcess":
+    case "rect":
+    default:
+      ctx.rect(0, 0, w, h);
+      break;
+  }
+}
+function roundRect(ctx, x, y, w, h, r) {
+  ctx.moveTo(x + r, y);
+  ctx.lineTo(x + w - r, y);
+  ctx.quadraticCurveTo(x + w, y, x + w, y + r);
+  ctx.lineTo(x + w, y + h - r);
+  ctx.quadraticCurveTo(x + w, y + h, x + w - r, y + h);
+  ctx.lineTo(x + r, y + h);
+  ctx.quadraticCurveTo(x, y + h, x, y + h - r);
+  ctx.lineTo(x, y + r);
+  ctx.quadraticCurveTo(x, y, x + r, y);
+  ctx.closePath();
+}
+function applyFill(ctx, style, w, h) {
+  if (style.fillMode === "gradient" && style.fillGradientStops?.length) {
+    const angle = (style.fillGradientAngle ?? 0) * Math.PI / 180;
+    const cx = w / 2;
+    const cy = h / 2;
+    const len = Math.max(w, h) / 2;
+    const dx = Math.cos(angle) * len;
+    const dy = Math.sin(angle) * len;
+    let grad;
+    if (style.fillGradientType === "radial") {
+      grad = ctx.createRadialGradient(cx, cy, 0, cx, cy, len);
+    } else {
+      grad = ctx.createLinearGradient(cx - dx, cy - dy, cx + dx, cy + dy);
+    }
+    for (const stop of style.fillGradientStops) {
+      const pos = Math.max(0, Math.min(1, stop.position));
+      grad.addColorStop(pos, stop.color);
+    }
+    ctx.fillStyle = grad;
+  } else if (style.fillColor && style.fillColor !== "transparent") {
+    ctx.fillStyle = style.fillColor;
+  } else {
+    ctx.fillStyle = "rgba(0,0,0,0)";
+  }
+  if (style.fillOpacity !== void 0 && style.fillOpacity < 1) {
+    ctx.globalAlpha = style.fillOpacity;
+  }
+}
+function applyStroke(ctx, style) {
+  ctx.strokeStyle = style.strokeColor ?? "#000000";
+  ctx.lineWidth = style.strokeWidth ?? 1;
+  if (style.strokeOpacity !== void 0 && style.strokeOpacity < 1) {
+    ctx.globalAlpha = style.strokeOpacity;
+  }
+}
+function hasVisibleFill(style) {
+  if (style.fillMode === "none") {
+    return false;
+  }
+  if (style.fillMode === "gradient" && style.fillGradientStops?.length) {
+    return true;
+  }
+  if (style.fillMode === "solid" || style.fillMode === "pattern") {
+    return Boolean(style.fillColor) && style.fillColor !== "transparent";
+  }
+  if (style.fillMode === "image") {
+    return Boolean(style.fillImageUrl);
+  }
+  if (style.fillColor && style.fillColor !== "transparent") {
+    return true;
+  }
+  return false;
+}
+function hasVisibleStroke(style) {
+  return Boolean(style.strokeColor) && style.strokeColor !== "transparent" && (style.strokeWidth ?? 0) > 0;
+}
+
+// src/converter/elements/TextElementProcessor.ts
+var TextElementProcessor = class {
+  constructor(textRenderer) {
+    this.textRenderer = textRenderer;
+  }
+  supportedTypes = ["text", "shape", "connector"];
+  async process(element, ctx) {
+    if (!hasTextProperties(element)) {
+      return null;
+    }
+    const textElement = element;
+    const parts = [];
+    const fillImage = await this.extractShapeFillImage(element, ctx);
+    if (fillImage) {
+      parts.push(fillImage);
+    }
+    const hasVisualShape = this.shapeHasVisibleStyling(element);
+    if (textElement.textSegments && textElement.textSegments.length > 0) {
+      let compositeRendered = false;
+      if (hasVisualShape) {
+        const compositeImage = await this.renderShapeAsImage(
+          element,
+          ctx,
+          textElement.textSegments,
+          textElement.textStyle
+        );
+        if (compositeImage) {
+          parts.push(compositeImage);
+          compositeRendered = true;
+        }
+      }
+      const bulletImages = await this.extractPictureBullets(textElement.textSegments, ctx);
+      if (bulletImages.length > 0) {
+        parts.push(...bulletImages);
+      }
+      if (!compositeRendered) {
+        const renderOpts = {
+          paragraphIndents: textElement.paragraphIndents,
+          slideNumber: ctx.slideNumber,
+          htmlFormatting: ctx.layoutScale !== void 0 && !ctx.semanticMode
+        };
+        const content = this.textRenderer.render(textElement.textSegments, renderOpts);
+        if (content.trim()) {
+          let textBlock = content;
+          if (textElement.linkedTxbxId !== void 0 && (textElement.linkedTxbxSeq ?? 0) > 0) {
+            const contLabel = `continued from linked text box ${textElement.linkedTxbxId}`;
+            textBlock += `
+
+*[${contLabel}]*`;
+          }
+          parts.push(textBlock);
+        }
+      }
+    } else {
+      const fallbackText = textElement.text?.trim();
+      if (fallbackText) {
+        const align = textElement.textStyle?.align;
+        if (align && align !== "left") {
+          parts.push(`<p align="${align}">${fallbackText}</p>`);
+        } else {
+          parts.push(fallbackText);
+        }
+      }
+    }
+    const warp = textElement.textStyle?.textWarpPreset;
+    if (warp && warp !== "textNoShape") {
+      parts.push(`*Text warp: ${warp}*`);
+    }
+    if (parts.length === 0 && textElement.promptText) {
+      parts.push(`*[Placeholder: ${textElement.promptText}]*`);
+    }
+    if (parts.length === 0) {
+      const shapeImage = await this.renderShapeAsImage(element, ctx, void 0, void 0);
+      if (shapeImage) {
+        parts.push(shapeImage);
+      }
+    }
+    if (parts.length === 0) {
+      return null;
+    }
+    return parts.join("\n\n");
+  }
+  async extractPictureBullets(segments, ctx) {
+    const extracted = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const segment of segments) {
+      const dataUrl = segment.bulletInfo?.imageDataUrl;
+      if (!dataUrl || !dataUrl.startsWith("data:") || seen.has(dataUrl)) {
+        continue;
+      }
+      seen.add(dataUrl);
+      try {
+        const path = await ctx.mediaContext.saveImage(dataUrl, `slide${ctx.slideNumber}-bullet`);
+        extracted.push(`<img src="${path}" alt="Bullet image">`);
+      } catch {
+      }
+    }
+    return extracted;
+  }
+  async extractShapeFillImage(element, ctx) {
+    const style = element.shapeStyle;
+    if (!style) {
+      return null;
+    }
+    if (style.fillMode !== "image" || !style.fillImageUrl) {
+      return null;
+    }
+    if (!style.fillImageUrl.startsWith("data:")) {
+      return null;
+    }
+    try {
+      const path = await ctx.mediaContext.saveImage(
+        style.fillImageUrl,
+        `slide${ctx.slideNumber}-shapefill`
+      );
+      if (ctx.semanticMode) {
+        return `![Shape fill](${path})`;
+      }
+      return `<img src="${path}" alt="Shape fill">`;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Renders a shape with visible fill/stroke (optionally with text)
+   * to a PNG image so it appears in the markdown output.
+   */
+  async renderShapeAsImage(element, ctx, textSegments, textStyle) {
+    const shape = element;
+    if (!shape.shapeStyle || !shape.width || !shape.height) {
+      return null;
+    }
+    try {
+      const dataUrl = renderShapeToDataUrl({
+        width: shape.width,
+        height: shape.height,
+        shapeType: shape.shapeType,
+        pathData: shape.pathData,
+        pathWidth: shape.pathWidth,
+        pathHeight: shape.pathHeight,
+        shapeStyle: shape.shapeStyle,
+        textSegments,
+        textStyle
+      });
+      if (!dataUrl) {
+        return null;
+      }
+      const imgPath = await ctx.mediaContext.saveImage(dataUrl, `slide${ctx.slideNumber}-shape`);
+      if (ctx.semanticMode) {
+        return `![Shape](${imgPath})`;
+      }
+      if (ctx.layoutScale) {
+        return `<img src="${imgPath}" alt="Shape" style="max-width:100%;height:auto">`;
+      }
+      const dims = this.computeDisplaySize(shape.width, shape.height);
+      return `<img src="${imgPath}" alt="Shape" width="${dims.w}" height="${dims.h}">`;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Checks whether the element has a visible fill or stroke that
+   * would benefit from being rendered as an image.
+   */
+  shapeHasVisibleStyling(element) {
+    const style = element.shapeStyle;
+    if (!style) {
+      return false;
+    }
+    if (style.fillMode === "none" && !style.strokeColor) {
+      return false;
+    }
+    if (style.fillColor && style.fillColor !== "transparent") {
+      return true;
+    }
+    if (style.fillMode === "gradient" && (style.fillGradientStops?.length ?? 0) > 0) {
+      return true;
+    }
+    if (style.strokeColor && style.strokeColor !== "transparent" && (style.strokeWidth ?? 0) > 0) {
+      return true;
+    }
+    return false;
+  }
+  /** Scale element dimensions to a sensible display size, capping width. */
+  computeDisplaySize(origW, origH, maxW = 600) {
+    if (origW <= 0 || origH <= 0) {
+      return { w: 100, h: 100 };
+    }
+    if (origW <= maxW) {
+      return { w: Math.round(origW), h: Math.round(origH) };
+    }
+    const scale = maxW / origW;
+    return { w: maxW, h: Math.round(origH * scale) };
+  }
+};
+
+// src/converter/SlideMetadataRenderer.ts
+var SlideMetadataRenderer = class {
+  constructor(textRenderer) {
+    this.textRenderer = textRenderer;
+  }
+  /**
+   * Renders the slide transition effect as a short metadata line.
+   */
+  renderTransition(slide) {
+    const tr = slide.transition;
+    if (!tr || !tr.type || tr.type === "none") {
+      return "";
+    }
+    const parts = [];
+    parts.push(`**Transition:** ${tr.type}`);
+    if (tr.direction) {
+      parts.push(`direction: ${tr.direction}`);
+    }
+    if (typeof tr.durationMs === "number") {
+      parts.push(`${tr.durationMs}ms`);
+    }
+    if (tr.advanceOnClick === false) {
+      parts.push("no click advance");
+    }
+    if (typeof tr.advanceAfterMs === "number") {
+      parts.push(`auto-advance: ${tr.advanceAfterMs}ms`);
+    }
+    if (tr.soundFileName) {
+      parts.push(`sound: ${tr.soundFileName}`);
+    }
+    return `*${parts.join(" | ")}*`;
+  }
+  /**
+   * Renders the slide's animation effects grouped by click sequence.
+   */
+  renderAnimations(slide) {
+    const native = slide.nativeAnimations;
+    const legacy = slide.animations;
+    const items = native?.length ? native : this.mapLegacyAnimations(legacy);
+    if (items.length === 0) {
+      return "";
+    }
+    const clickGroups = this.groupByClickSequence(items);
+    const lines = ["### Animations"];
+    for (let gi = 0; gi < clickGroups.length; gi += 1) {
+      const group = clickGroups[gi];
+      lines.push(`- **Click ${gi + 1}:**`);
+      for (const anim of group) {
+        lines.push(`  - ${this.summariseAnimation(anim)}`);
+      }
+    }
+    return lines.length > 1 ? lines.join("\n") : "";
+  }
+  /**
+   * Renders any compatibility warnings for the slide.
+   */
+  renderWarnings(slide) {
+    const raw = slide.warnings;
+    if (!raw || raw.length === 0) {
+      return "";
+    }
+    const lines = ["### Warnings"];
+    for (const w of raw) {
+      const icon = w.severity === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+      lines.push(`- ${icon} ${w.message}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Renders any review comments attached to the slide.
+   */
+  renderComments(slide) {
+    if (!slide.comments || slide.comments.length === 0) {
+      return "";
+    }
+    const lines = ["### Comments"];
+    for (const comment of slide.comments) {
+      const author = comment.author?.trim() || "Unknown";
+      const createdAt = comment.createdAt ? ` (${comment.createdAt})` : "";
+      const resolved = comment.resolved ? " [resolved]" : "";
+      lines.push(`- **${author}**${createdAt}: ${comment.text}${resolved}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Renders the slide's speaker notes as a Markdown blockquote.
+   */
+  renderNotes(slide) {
+    const notesFromSegments = slide.notesSegments ? this.textRenderer.render(slide.notesSegments) : "";
+    const notesText = (notesFromSegments || slide.notes || "").trim();
+    if (!notesText) {
+      return "";
+    }
+    const quoted = notesText.split(/\r?\n/).map((line) => `> ${line}`).join("\n");
+    return `> **Speaker Notes**
+${quoted}`;
+  }
+  /**
+   * Groups animations by click sequence. Each `onClick` trigger starts
+   * a new group; `withPrevious` and `afterPrevious` are appended to the
+   * current group.
+   */
+  groupByClickSequence(items) {
+    const groups = [];
+    for (const item of items) {
+      const trigger = item.trigger ?? "onClick";
+      if (trigger === "onClick" || groups.length === 0) {
+        groups.push([item]);
+      } else {
+        groups[groups.length - 1].push(item);
+      }
+    }
+    return groups;
+  }
+  /**
+   * Converts legacy animation data into the NativeAnimationLike shape.
+   */
+  mapLegacyAnimations(legacy) {
+    if (!legacy?.length) {
+      return [];
+    }
+    return legacy.map((a) => {
+      let presetClass = "entr";
+      if (a.exit) {
+        presetClass = "exit";
+      } else if (a.emphasis) {
+        presetClass = "emph";
+      } else if (a.motionPath) {
+        presetClass = "path";
+      }
+      return {
+        trigger: a.trigger,
+        presetClass,
+        durationMs: a.durationMs,
+        motionPath: a.motionPath
+      };
+    });
+  }
+  /**
+   * Produces a human-readable summary of a single animation effect.
+   */
+  summariseAnimation(anim) {
+    const classLabels = {
+      entr: "Entrance",
+      exit: "Exit",
+      emph: "Emphasis",
+      path: "Motion Path"
+    };
+    const classLabel = classLabels[anim.presetClass ?? "entr"] ?? "Effect";
+    const name = anim.presetName ?? (anim.presetId ? `preset ${anim.presetId}` : "effect");
+    const details = [];
+    if (anim.targetId) {
+      details.push(`target: ${anim.targetId}`);
+    }
+    if (typeof anim.durationMs === "number") {
+      details.push(`${anim.durationMs}ms`);
+    }
+    if (typeof anim.delayMs === "number" && anim.delayMs > 0) {
+      details.push(`delay: ${anim.delayMs}ms`);
+    }
+    const trigger = anim.trigger ?? "onClick";
+    if (trigger !== "onClick") {
+      details.push(
+        trigger.replace(/([A-Z])/g, " $1").trim().toLowerCase()
+      );
+    }
+    if (typeof anim.repeatCount === "number" && anim.repeatCount > 1) {
+      details.push(`repeat: ${anim.repeatCount}x`);
+    }
+    if (anim.autoReverse) {
+      details.push("auto-reverse");
+    }
+    if (anim.buildType) {
+      details.push(`build: ${anim.buildType}`);
+    }
+    const suffix = details.length > 0 ? ` (${details.join(", ")})` : "";
+    return `${classLabel}: ${name}${suffix}`;
+  }
+};
+
+// src/converter/SlideProcessor.ts
+var SlideProcessor = class {
+  /**
+   * @param registry - Registry of element-type processors.
+   * @param mediaContext - Shared media extraction context.
+   * @param textRenderer - Renderer for rich-text segments.
+   */
+  constructor(registry, mediaContext, textRenderer) {
+    this.registry = registry;
+    this.mediaContext = mediaContext;
+    this.textRenderer = textRenderer;
+    this.metadataRenderer = new SlideMetadataRenderer(textRenderer);
+  }
+  /** Delegate for rendering slide-level metadata sections. */
+  metadataRenderer;
+  /** Processes a slide into a complete Markdown section. */
+  async processSlide(slide, options) {
+    const isSemantic = options.semanticMode === true;
+    const title = this.detectTitle(slide);
+    const heading = this.buildHeading(slide, title);
+    const context = {
+      mediaContext: this.mediaContext,
+      slideNumber: slide.slideNumber,
+      slideWidth: options.slideWidth,
+      slideHeight: options.slideHeight,
+      semanticMode: isSemantic,
+      processElements: async (elements) => {
+        const sorted = this.sortElementsByReadingOrder(elements);
+        const output = [];
+        for (const element of sorted) {
+          const rendered = await this.registry.processElement(element, context);
+          if (rendered && rendered.trim().length > 0) {
+            output.push(rendered);
+          }
+        }
+        return output;
+      }
+    };
+    const parts = [heading];
+    const transition = this.metadataRenderer.renderTransition(slide);
+    if (transition) {
+      parts.push(transition);
+    }
+    if (isSemantic) {
+      const elementContent = await this.processElementsSemantic(slide.elements, context);
+      parts.push(...elementContent);
+    } else {
+      const backgroundHtml = await this.renderBackgroundHtml(slide, context);
+      const elementContent = await this.processElementsWithLayout(
+        slide.elements,
+        context,
+        backgroundHtml
+      );
+      parts.push(...elementContent);
+    }
+    const animations = this.metadataRenderer.renderAnimations(slide);
+    if (animations) {
+      parts.push(animations);
+    }
+    const warnings = this.metadataRenderer.renderWarnings(slide);
+    if (warnings) {
+      parts.push(warnings);
+    }
+    const comments = this.metadataRenderer.renderComments(slide);
+    if (comments) {
+      parts.push(comments);
+    }
+    if (options.includeSpeakerNotes) {
+      const notes = this.metadataRenderer.renderNotes(slide);
+      if (notes) {
+        parts.push(notes);
+      }
+    }
+    return parts.join("\n\n");
+  }
+  /**
+   * Builds the Markdown heading line for a slide, including its number,
+   * detected title text, and flags (hidden, layout name).
+   */
+  buildHeading(slide, title) {
+    const flags = [];
+    if (slide.hidden) {
+      flags.push("hidden");
+    }
+    if (slide.layoutName) {
+      flags.push(`layout: ${slide.layoutName}`);
+    }
+    const suffix = flags.length > 0 ? ` *(${flags.join(", ")})*` : "";
+    if (title) {
+      return `## Slide ${slide.slideNumber}: ${title}${suffix}`;
+    }
+    return `## Slide ${slide.slideNumber}${suffix}`;
+  }
+  /**
+   * Returns an HTML `<img>` for the slide background that can be
+   * placed as the bottom-most layer inside the positioned container.
+   */
+  async renderBackgroundHtml(slide, ctx) {
+    if (!slide.backgroundImage) {
+      return void 0;
+    }
+    if (!slide.backgroundImage.startsWith("data:")) {
+      return void 0;
+    }
+    try {
+      const path = await ctx.mediaContext.saveImage(
+        slide.backgroundImage,
+        `slide${slide.slideNumber}-bg`
+      );
+      return `<img src="${path}" alt="Slide background" style="width:100%;height:100%;object-fit:cover">`;
+    } catch {
+      return void 0;
+    }
+  }
+  /** Detects the slide's title from placeholder or first text element. */
+  detectTitle(slide) {
+    for (const element of slide.elements) {
+      const phType = this.getPlaceholderType(element);
+      if (phType === "title" || phType === "ctrTitle" || phType === "subTitle") {
+        if (!hasTextProperties(element)) {
+          continue;
+        }
+        const textFromSegments = element.textSegments ? this.textRenderer.plainText(element.textSegments) : "";
+        const text = (textFromSegments || element.text || "").trim();
+        if (text) {
+          return text.slice(0, 120);
+        }
+      }
+    }
+    const sorted = this.sortElementsByReadingOrder(slide.elements);
+    for (const element of sorted) {
+      if (!hasTextProperties(element)) {
+        continue;
+      }
+      const textFromSegments = element.textSegments ? this.textRenderer.plainText(element.textSegments) : "";
+      const text = (textFromSegments || element.text || "").trim();
+      if (!text) {
+        continue;
+      }
+      return text.slice(0, 120);
+    }
+    return void 0;
+  }
+  /**
+   * Extracts the placeholder type from an element, if present.
+   */
+  getPlaceholderType(element) {
+    const el = element;
+    return el.placeholderType;
+  }
+  /** Processes elements as clean semantic markdown. */
+  async processElementsSemantic(elements, context) {
+    if (elements.length === 0) {
+      return [];
+    }
+    const sorted = this.sortElementsByReadingOrder(elements);
+    const output = [];
+    for (const elem of sorted) {
+      const rendered = await this.registry.processElement(elem, context);
+      if (rendered?.trim()) {
+        output.push(rendered);
+      }
+    }
+    return output;
+  }
+  /** Processes elements using CSS absolute positioning. */
+  async processElementsWithLayout(elements, context, backgroundHtml) {
+    if (elements.length === 0 && !backgroundHtml) {
+      return [];
+    }
+    const slideW = context.slideWidth || 960;
+    const slideH = context.slideHeight || 540;
+    const maxDisplayW = 960;
+    const scale = slideW > maxDisplayW ? maxDisplayW / slideW : 1;
+    const displayW = Math.round(slideW * scale);
+    const displayH = Math.round(slideH * scale);
+    const sorted = this.sortElementsByReadingOrder(elements);
+    const positionedCells = [];
+    const layoutContext = {
+      ...context,
+      layoutScale: scale
+    };
+    if (backgroundHtml) {
+      positionedCells.push(
+        `<div style="position:absolute;left:0;top:0;width:${displayW}px;height:${displayH}px">${backgroundHtml}</div>`
+      );
+    }
+    for (const elem of sorted) {
+      const rendered = await this.registry.processElement(elem, layoutContext);
+      if (!rendered?.trim()) {
+        continue;
+      }
+      const left = Math.round(elem.x * scale);
+      const top = Math.round(elem.y * scale);
+      const w = Math.round(elem.width * scale);
+      const h = Math.round(elem.height * scale);
+      positionedCells.push(
+        `<div style="position:absolute;left:${left}px;top:${top}px;width:${w}px;height:${h}px;overflow:hidden">${rendered}</div>`
+      );
+    }
+    if (positionedCells.length === 0) {
+      return [];
+    }
+    const container = [
+      `<div style="position:relative;width:${displayW}px;height:${displayH}px;border:1px solid #e5e7eb;overflow:hidden;margin:0.5em 0">`,
+      ...positionedCells,
+      "</div>"
+    ].join("\n");
+    return [container];
+  }
+  /** Sorts elements into natural reading order (top-to-bottom, left-to-right). */
+  sortElementsByReadingOrder(elements) {
+    return [...elements].sort((left, right) => {
+      const yDistance = (left.y ?? 0) - (right.y ?? 0);
+      if (Math.abs(yDistance) > 8) {
+        return yDistance;
+      }
+      return (left.x ?? 0) - (right.x ?? 0);
+    });
+  }
+};
+
+// src/converter/ListMarkerHelper.ts
+function resolveListLevel(bulletInfo, paragraphIndex, paragraphIndents) {
+  const explicitLevel = readNumericProp(bulletInfo, "level");
+  if (typeof explicitLevel === "number") {
+    return Math.max(0, Math.floor(explicitLevel));
+  }
+  const indentInfo = paragraphIndents?.[paragraphIndex];
+  const marginLeft = indentInfo?.marginLeft ?? 0;
+  const indent = indentInfo?.indent ?? 0;
+  const spacingPoints = Math.max(0, marginLeft + Math.max(indent, 0));
+  if (spacingPoints <= 0) {
+    return 0;
+  }
+  return Math.max(0, Math.round(spacingPoints / 24));
+}
+function resolveListMarker(bulletInfo, paragraphIndex) {
+  if (bulletInfo.autoNumType) {
+    const startAt = bulletInfo.autoNumStartAt ?? 1;
+    const offset = bulletInfo.paragraphIndex ?? paragraphIndex;
+    const value = Math.max(1, startAt + offset);
+    return formatAutoNumber(value, bulletInfo.autoNumType);
+  }
+  if (bulletInfo.imageRelId || bulletInfo.imageDataUrl) {
+    return "-";
+  }
+  if (bulletInfo.char) {
+    const marker = bulletInfo.char.trim();
+    if (/^[-*+>]$/.test(marker)) {
+      return marker;
+    }
+  }
+  return "-";
+}
+function formatAutoNumber(value, autoNumType) {
+  const normalized = autoNumType.toLowerCase();
+  let token = String(value);
+  if (normalized.includes("roman")) {
+    token = toRoman(value);
+    if (normalized.includes("lc")) {
+      token = token.toLowerCase();
+    }
+  }
+  if (normalized.includes("alpha")) {
+    token = toAlphabetic(value);
+    if (normalized.includes("uc")) {
+      token = token.toUpperCase();
+    }
+    if (normalized.includes("lc")) {
+      token = token.toLowerCase();
+    }
+  }
+  if (normalized.includes("parenboth")) {
+    return `(${token})`;
+  }
+  if (normalized.includes("parenr")) {
+    return `${token})`;
+  }
+  if (normalized.includes("minus")) {
+    return `${token}-`;
+  }
+  return `${token}.`;
+}
+function toAlphabetic(value) {
+  let remaining = Math.max(1, value);
+  let result = "";
+  while (remaining > 0) {
+    remaining -= 1;
+    result = String.fromCharCode(97 + remaining % 26) + result;
+    remaining = Math.floor(remaining / 26);
+  }
+  return result;
+}
+function toRoman(value) {
+  const numerals = [
+    [1e3, "M"],
+    [900, "CM"],
+    [500, "D"],
+    [400, "CD"],
+    [100, "C"],
+    [90, "XC"],
+    [50, "L"],
+    [40, "XL"],
+    [10, "X"],
+    [9, "IX"],
+    [5, "V"],
+    [4, "IV"],
+    [1, "I"]
+  ];
+  let remaining = Math.max(1, value);
+  let result = "";
+  for (const [numeric, literal] of numerals) {
+    while (remaining >= numeric) {
+      result += literal;
+      remaining -= numeric;
+    }
+  }
+  return result;
+}
+function readNumericProp(source, key) {
+  if (!source || typeof source !== "object") {
+    return void 0;
+  }
+  const value = source[key];
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    return void 0;
+  }
+  return value;
+}
+var MONOSPACE_PATTERNS = [
+  "mono",
+  "courier",
+  "consolas",
+  "code",
+  "menlo",
+  "fira",
+  "hack",
+  "inconsolata",
+  "jetbrains",
+  "source code",
+  "cascadia",
+  "sf mono",
+  "roboto mono",
+  "iosevka",
+  "dejavu sans mono",
+  "droid sans mono",
+  "ubuntu mono",
+  "liberation mono",
+  "noto mono",
+  "ibm plex mono",
+  "lucida console",
+  "fixedsys"
+];
+function isCodeLikeFont(segment) {
+  if (segment.style.hyperlink) {
+    return false;
+  }
+  const family = segment.style.fontFamily?.toLowerCase() ?? "";
+  return MONOSPACE_PATTERNS.some((pattern) => family.includes(pattern));
+}
+
+// src/converter/OmmlLatexConverter.ts
+var OmmlLatexConverter = class {
+  /** Extracts LaTeX from an OMML XML node tree. */
+  convert(root) {
+    const rendered = this.renderNode(root).replace(/\s+/g, " ").trim();
+    if (rendered) {
+      return rendered;
+    }
+    return this.collectText(root).replace(/\s+/g, " ").trim();
+  }
+  renderNode(node) {
+    if (node === null || node === void 0) {
+      return "";
+    }
+    if (typeof node === "string") {
+      return node;
+    }
+    if (typeof node === "number") {
+      return String(node);
+    }
+    if (Array.isArray(node)) {
+      return node.map((entry) => this.renderNode(entry)).join("");
+    }
+    if (typeof node !== "object") {
+      return "";
+    }
+    const record = node;
+    if (typeof record["#text"] === "string") {
+      return record["#text"];
+    }
+    if (typeof record["m:t"] === "string") {
+      return String(record["m:t"]);
+    }
+    if (record["m:t"]) {
+      return this.renderNode(record["m:t"]);
+    }
+    const handlers = [
+      (r) => this.tryFraction(r),
+      (r) => this.trySuperscript(r),
+      (r) => this.trySubscript(r),
+      (r) => this.trySubSup(r),
+      (r) => this.tryRadical(r),
+      (r) => this.tryNary(r),
+      (r) => this.tryDelimiter(r),
+      (r) => this.tryMatrix(r),
+      (r) => this.tryFunction(r),
+      (r) => this.tryBar(r),
+      (r) => this.tryGroupChar(r),
+      (r) => this.tryLimLow(r),
+      (r) => this.tryLimUpp(r)
+    ];
+    for (const handler of handlers) {
+      const result = handler(record);
+      if (result) {
+        return result;
+      }
+    }
+    const ignored = /* @__PURE__ */ new Set(["@_", "m:rPr", "m:ctrlPr", "m:argPr"]);
+    let output = "";
+    for (const [key, value] of Object.entries(record)) {
+      if (ignored.has(key) || key.startsWith("@_")) {
+        continue;
+      }
+      output += this.renderNode(value);
+    }
+    return output;
+  }
+  tryFraction(node) {
+    const value = node["m:f"];
+    if (!value) {
+      return null;
+    }
+    const f = this.firstRecord(value);
+    if (!f) {
+      return null;
+    }
+    const num = this.renderNode(f["m:num"]).trim();
+    const den = this.renderNode(f["m:den"]).trim();
+    if (!num && !den) {
+      return null;
+    }
+    return `\\frac{${num || " "}}{${den || " "}}`;
+  }
+  trySuperscript(node) {
+    const value = node["m:sSup"];
+    if (!value) {
+      return null;
+    }
+    const sup = this.firstRecord(value);
+    if (!sup) {
+      return null;
+    }
+    const base = this.renderNode(sup["m:e"]).trim();
+    const exp = this.renderNode(sup["m:sup"]).trim();
+    if (!base && !exp) {
+      return null;
+    }
+    return `${base}^{${exp || " "}}`;
+  }
+  trySubscript(node) {
+    const value = node["m:sSub"];
+    if (!value) {
+      return null;
+    }
+    const sub = this.firstRecord(value);
+    if (!sub) {
+      return null;
+    }
+    const base = this.renderNode(sub["m:e"]).trim();
+    const idx = this.renderNode(sub["m:sub"]).trim();
+    if (!base && !idx) {
+      return null;
+    }
+    return `${base}_{${idx || " "}}`;
+  }
+  trySubSup(node) {
+    const value = node["m:sSubSup"];
+    if (!value) {
+      return null;
+    }
+    const ss = this.firstRecord(value);
+    if (!ss) {
+      return null;
+    }
+    const base = this.renderNode(ss["m:e"]).trim();
+    const sub = this.renderNode(ss["m:sub"]).trim();
+    const sup = this.renderNode(ss["m:sup"]).trim();
+    if (!base && !sub && !sup) {
+      return null;
+    }
+    return `${base}_{${sub || " "}}^{${sup || " "}}`;
+  }
+  tryRadical(node) {
+    const value = node["m:rad"];
+    if (!value) {
+      return null;
+    }
+    const rad = this.firstRecord(value);
+    if (!rad) {
+      return null;
+    }
+    const deg = this.renderNode(rad["m:deg"]).trim();
+    const expr = this.renderNode(rad["m:e"]).trim();
+    if (!expr && !deg) {
+      return null;
+    }
+    if (deg) {
+      return `\\sqrt[${deg}]{${expr || " "}}`;
+    }
+    return `\\sqrt{${expr || " "}}`;
+  }
+  tryNary(node) {
+    const value = node["m:nary"];
+    if (!value) {
+      return null;
+    }
+    const nary = this.firstRecord(value);
+    if (!nary) {
+      return null;
+    }
+    const naryPr = this.firstRecord(nary["m:naryPr"]);
+    const chrNode = this.firstRecord(naryPr?.["m:chr"]);
+    const symbol = this.readAttr(chrNode, "val") ?? "\\sum";
+    const lower = this.renderNode(nary["m:sub"]).trim();
+    const upper = this.renderNode(nary["m:sup"]).trim();
+    const expr = this.renderNode(nary["m:e"]).trim();
+    let prefix = symbol;
+    if (lower) {
+      prefix += `_{${lower}}`;
+    }
+    if (upper) {
+      prefix += `^{${upper}}`;
+    }
+    if (!expr) {
+      return prefix;
+    }
+    return `${prefix} ${expr}`;
+  }
+  tryDelimiter(node) {
+    const value = node["m:d"];
+    if (!value) {
+      return null;
+    }
+    const d = this.firstRecord(value);
+    if (!d) {
+      return null;
+    }
+    const dPr = this.firstRecord(d["m:dPr"]);
+    const begin = this.readAttr(this.firstRecord(dPr?.["m:begChr"]), "val") ?? "(";
+    const end = this.readAttr(this.firstRecord(dPr?.["m:endChr"]), "val") ?? ")";
+    const expr = this.renderNode(d["m:e"]).trim();
+    if (!expr) {
+      return null;
+    }
+    return `\\left${begin}${expr}\\right${end}`;
+  }
+  tryMatrix(node) {
+    const value = node["m:m"];
+    if (!value) {
+      return null;
+    }
+    const m = this.firstRecord(value);
+    if (!m) {
+      return null;
+    }
+    const rows = this.toRecordArray(m["m:mr"]).map((row) => {
+      const cells = this.toRecordArray(row["m:e"]).map((entry) => this.renderNode(entry).trim()).filter((entry) => entry.length > 0);
+      return cells.join(" & ");
+    }).filter((row) => row.length > 0);
+    if (rows.length === 0) {
+      return null;
+    }
+    return `\\begin{matrix}${rows.join(" \\\\ ")}\\end{matrix}`;
+  }
+  /** Renders m:func (named functions like sin, cos, lim). */
+  tryFunction(node) {
+    const value = node["m:func"];
+    if (!value) {
+      return null;
+    }
+    const func = this.firstRecord(value);
+    if (!func) {
+      return null;
+    }
+    const name = this.renderNode(func["m:fName"]).trim();
+    const expr = this.renderNode(func["m:e"]).trim();
+    if (!name) {
+      return null;
+    }
+    return `\\${name}{${expr || " "}}`;
+  }
+  /** Renders m:bar (overline / underline). */
+  tryBar(node) {
+    const value = node["m:bar"];
+    if (!value) {
+      return null;
+    }
+    const bar = this.firstRecord(value);
+    if (!bar) {
+      return null;
+    }
+    const barPr = this.firstRecord(bar["m:barPr"]);
+    const pos = this.readAttr(this.firstRecord(barPr?.["m:pos"]), "val");
+    const expr = this.renderNode(bar["m:e"]).trim();
+    if (!expr) {
+      return null;
+    }
+    return pos === "bot" ? `\\underline{${expr}}` : `\\overline{${expr}}`;
+  }
+  /** Renders m:groupChr (brace/bracket above or below expression). */
+  tryGroupChar(node) {
+    const value = node["m:groupChr"];
+    if (!value) {
+      return null;
+    }
+    const gc = this.firstRecord(value);
+    if (!gc) {
+      return null;
+    }
+    const gcPr = this.firstRecord(gc["m:groupChrPr"]);
+    const pos = this.readAttr(this.firstRecord(gcPr?.["m:pos"]), "val");
+    const chr = this.readAttr(this.firstRecord(gcPr?.["m:chr"]), "val") ?? "\u23DF";
+    const expr = this.renderNode(gc["m:e"]).trim();
+    if (!expr) {
+      return null;
+    }
+    if (pos === "top" || chr === "\u23DE") {
+      return `\\overbrace{${expr}}`;
+    }
+    return `\\underbrace{${expr}}`;
+  }
+  /** Renders m:limLow (lower limit, e.g. lim_{x->0}). */
+  tryLimLow(node) {
+    const value = node["m:limLow"];
+    if (!value) {
+      return null;
+    }
+    const ll = this.firstRecord(value);
+    if (!ll) {
+      return null;
+    }
+    const base = this.renderNode(ll["m:e"]).trim();
+    const lim = this.renderNode(ll["m:lim"]).trim();
+    if (!base) {
+      return null;
+    }
+    return lim ? `${base}_{${lim}}` : base;
+  }
+  /** Renders m:limUpp (upper limit). */
+  tryLimUpp(node) {
+    const value = node["m:limUpp"];
+    if (!value) {
+      return null;
+    }
+    const lu = this.firstRecord(value);
+    if (!lu) {
+      return null;
+    }
+    const base = this.renderNode(lu["m:e"]).trim();
+    const lim = this.renderNode(lu["m:lim"]).trim();
+    if (!base) {
+      return null;
+    }
+    return lim ? `${base}^{${lim}}` : base;
+  }
+  collectText(node) {
+    if (node === null || node === void 0) {
+      return "";
+    }
+    if (typeof node === "string" || typeof node === "number") {
+      return String(node);
+    }
+    if (Array.isArray(node)) {
+      return node.map((entry) => this.collectText(entry)).join(" ");
+    }
+    if (typeof node !== "object") {
+      return "";
+    }
+    const record = node;
+    const tokens = [];
+    if (typeof record["m:t"] === "string") {
+      tokens.push(record["m:t"]);
+    }
+    if (typeof record["#text"] === "string") {
+      tokens.push(record["#text"]);
+    }
+    for (const [key, value] of Object.entries(record)) {
+      if (key === "m:t" || key === "#text" || key.startsWith("@_")) {
+        continue;
+      }
+      tokens.push(this.collectText(value));
+    }
+    return tokens.join(" ");
+  }
+  firstRecord(value) {
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+          return entry;
+        }
+      }
+      return null;
+    }
+    if (value && typeof value === "object") {
+      return value;
+    }
+    return null;
+  }
+  toRecordArray(value) {
+    if (!value) {
+      return [];
+    }
+    if (Array.isArray(value)) {
+      return value.filter(
+        (entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)
+      );
+    }
+    if (typeof value === "object") {
+      return [value];
+    }
+    return [];
+  }
+  readAttr(node, key) {
+    if (!node) {
+      return null;
+    }
+    const direct = node[`@_${key}`];
+    if (typeof direct === "string") {
+      return direct;
+    }
+    const fallback = node[key];
+    if (typeof fallback === "string") {
+      return fallback;
+    }
+    return null;
+  }
+};
+
+// src/converter/TextSegmentRenderer.ts
+var TextSegmentRenderer = class {
+  ommlConverter = new OmmlLatexConverter();
+  render(segments, options = {}) {
+    if (segments.length === 0) {
+      return "";
+    }
+    const paragraphs = this.groupParagraphs(segments);
+    const renderedParagraphs = paragraphs.map((group) => this.renderParagraph(group, options)).filter((paragraph) => paragraph.text.length > 0);
+    if (renderedParagraphs.length === 0) {
+      return "";
+    }
+    if (options.inlineMode) {
+      return renderedParagraphs.map((entry) => entry.text).join("<br />");
+    }
+    if (options.htmlFormatting) {
+      return renderedParagraphs.map((entry) => entry.text).join("<br>");
+    }
+    const output = [];
+    for (let index = 0; index < renderedParagraphs.length; index += 1) {
+      if (index > 0) {
+        const previous = renderedParagraphs[index - 1];
+        const current = renderedParagraphs[index];
+        output.push(previous.isListItem && current.isListItem ? "\n" : "\n\n");
+      }
+      output.push(renderedParagraphs[index].text);
+    }
+    return output.join("");
+  }
+  renderInline(segments, options = {}) {
+    return this.render(segments, {
+      ...options,
+      inlineMode: true,
+      disableLists: true,
+      disableAlignment: true
+    });
+  }
+  plainText(segments, options = {}) {
+    const paragraphs = this.groupParagraphs(segments);
+    const rendered = paragraphs.map(
+      (group) => group.segments.map((segment) => {
+        const base = this.resolvePlainSegmentText(segment, options);
+        if (segment.rubyText) {
+          return `${base}(${segment.rubyText})`;
+        }
+        return base;
+      }).join("").trim()
+    ).filter((text) => text.length > 0);
+    return rendered.join(" ").trim();
+  }
+  groupParagraphs(segments) {
+    const groups = [];
+    let buffer = [];
+    let paragraphIndex = 0;
+    for (const segment of segments) {
+      if (segment.isParagraphBreak) {
+        if (buffer.length > 0) {
+          groups.push({ index: paragraphIndex, segments: buffer });
+          buffer = [];
+        }
+        paragraphIndex += 1;
+        continue;
+      }
+      buffer.push(segment);
+    }
+    if (buffer.length > 0) {
+      groups.push({ index: paragraphIndex, segments: buffer });
+    }
+    return groups;
+  }
+  renderParagraph(group, options) {
+    let rawText = group.segments.map((segment) => this.renderSegment(segment, options)).join("");
+    if (options.htmlFormatting) {
+      rawText = rawText.replace(/<\/strong><strong>/g, "").replace(/<\/em><em>/g, "").replace(/<\/s><s>/g, "");
+    } else {
+      rawText = rawText.replace(/\*\*\*\*/g, "").replace(/~~~~/g, "");
+    }
+    if (options.htmlFormatting) {
+      rawText = rawText.replace(/\n/g, "<br>");
+    }
+    rawText = rawText.trim();
+    if (!rawText) {
+      return { text: "", isListItem: false };
+    }
+    if (!options.disableLists && !options.inlineMode) {
+      const bullet = group.segments.find((segment) => Boolean(segment.bulletInfo))?.bulletInfo;
+      if (bullet && !bullet.none) {
+        const level = resolveListLevel(bullet, group.index, options.paragraphIndents);
+        const marker = resolveListMarker(bullet, group.index);
+        const alreadyNumbered = bullet.autoNumType && /^\d+[.)]\s/.test(rawText);
+        const prefix = alreadyNumbered ? "" : `${marker} `;
+        if (options.htmlFormatting) {
+          const pad = level * 1.5;
+          return {
+            text: `<div style="padding-left:${pad}em">${prefix}${rawText}</div>`,
+            isListItem: true
+          };
+        }
+        return {
+          text: `${"  ".repeat(level)}${prefix}${rawText}`,
+          isListItem: true
+        };
+      }
+    }
+    const align = group.segments[0]?.style.align;
+    if (!options.disableAlignment && !options.inlineMode && align && align !== "left") {
+      return {
+        text: `<p align="${align}">${rawText}</p>`,
+        isListItem: false
+      };
+    }
+    return { text: rawText, isListItem: false };
+  }
+  renderSegment(segment, options) {
+    const plain = this.resolvePlainSegmentText(segment, options);
+    if (!plain) {
+      return "";
+    }
+    if (segment.equationXml) {
+      const normalized = plain.trim() || "[equation]";
+      return `$${normalized}$`;
+    }
+    const useHtml = options.htmlFormatting ?? false;
+    let text = useHtml ? this.escapeHtml(plain) : this.escapeMarkdown(plain);
+    if (segment.rubyText) {
+      const rt = useHtml ? this.escapeHtml(segment.rubyText) : segment.rubyText;
+      if (useHtml) {
+        text = `<ruby>${text}<rp>(</rp><rt>${rt}</rt><rp>)</rp></ruby>`;
+      } else {
+        text = `${text}(${rt})`;
+      }
+    }
+    if (segment.style.textCaps === "all") {
+      text = text.toUpperCase();
+    }
+    if (!useHtml && isCodeLikeFont(segment)) {
+      text = this.wrapCode(text);
+    }
+    if (segment.style.strikethrough) {
+      text = useHtml ? `<s>${text}</s>` : `~~${text}~~`;
+    }
+    if (segment.style.bold && segment.style.italic) {
+      text = useHtml ? `<strong><em>${text}</em></strong>` : `***${text}***`;
+    } else {
+      if (segment.style.bold) {
+        text = useHtml ? `<strong>${text}</strong>` : `**${text}**`;
+      }
+      if (segment.style.italic) {
+        text = useHtml ? `<em>${text}</em>` : `*${text}*`;
+      }
+    }
+    if (segment.style.underline) {
+      text = `<u>${text}</u>`;
+    }
+    if (segment.style.baseline && segment.style.baseline > 0) {
+      text = `<sup>${text}</sup>`;
+    }
+    if (segment.style.baseline && segment.style.baseline < 0) {
+      text = `<sub>${text}</sub>`;
+    }
+    if (segment.style.textCaps === "small") {
+      text = `<span style="font-variant:small-caps">${text}</span>`;
+    }
+    if (segment.style.hyperlink) {
+      const dest = this.renderLinkDestination(segment.style.hyperlink);
+      if (useHtml) {
+        text = `<a href="${dest}">${text}</a>`;
+      } else {
+        const title = segment.style.hyperlinkTooltip ? ` "${this.escapeLinkTitle(segment.style.hyperlinkTooltip)}"` : "";
+        text = `[${text}](${dest}${title})`;
+      }
+    }
+    if (segment.style.rtl) {
+      text = `\u200F${text}`;
+    }
+    return text;
+  }
+  resolvePlainSegmentText(segment, options) {
+    if (segment.fieldType) {
+      return this.resolveFieldSegment(segment.fieldType, segment.text, options);
+    }
+    if (segment.equationXml) {
+      const fromXml = this.ommlConverter.convert(segment.equationXml).trim();
+      if (fromXml) {
+        return fromXml;
+      }
+      if (segment.text.trim()) {
+        return segment.text.trim();
+      }
+      return "[equation]";
+    }
+    return segment.text;
+  }
+  resolveFieldSegment(fieldType, defaultText, options) {
+    const normalized = fieldType.trim().toLowerCase();
+    if (normalized.includes("slidenum")) {
+      if (typeof options.slideNumber === "number") {
+        return String(options.slideNumber);
+      }
+      return defaultText;
+    }
+    if (normalized.includes("datetime") || normalized.includes("date")) {
+      if (options.dateTimeText) {
+        return options.dateTimeText;
+      }
+      return defaultText;
+    }
+    return defaultText;
+  }
+  wrapCode(text) {
+    const matches = text.match(/`+/g);
+    const maxTicks = matches && matches.length > 0 ? Math.max(...matches.map((entry) => entry.length)) : 0;
+    const fence = "`".repeat(Math.max(1, maxTicks + 1));
+    return `${fence}${text}${fence}`;
+  }
+  renderLinkDestination(href) {
+    if (/\s/.test(href) || href.includes(")")) {
+      return `<${href}>`;
+    }
+    return href;
+  }
+  escapeLinkTitle(value) {
+    return value.replace(/"/g, "&quot;");
+  }
+  escapeMarkdown(text) {
+    return text.replace(/([\\`*_{}[\]|])/g, "\\$1");
+  }
+  escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+};
+
+// src/converter/PptxMarkdownConverter.ts
+var PptxMarkdownConverter = class extends DocumentConverter {
+  /** Renderer for rich-text segments (bold, italic, hyperlinks, etc.). */
+  textRenderer;
+  /** Registry mapping element types to their dedicated processors. */
+  registry;
+  /** Delegate responsible for converting individual slides. */
+  slideProcessor;
+  /** Number of slides actually converted (after applying the slide range filter). */
+  convertedSlides = 0;
+  /** Total number of slides in the source presentation. */
+  totalSlides = 0;
+  /**
+   * @param outputDir - Root directory for output files.
+   * @param options - PPTX-specific conversion options.
+   * @param fs - Optional file system adapter for writing media to disk.
+   */
+  constructor(outputDir, options, fs) {
+    super(outputDir, options, fs);
+    this.textRenderer = new TextSegmentRenderer();
+    this.registry = new ElementProcessorRegistry();
+    this.registerProcessors();
+    this.slideProcessor = new SlideProcessor(this.registry, this.mediaContext, this.textRenderer);
+  }
+  /** Returns the number of images extracted and saved during conversion. */
+  get imagesExtracted() {
+    return this.mediaContext.totalImages;
+  }
+  /** Returns the media directory path, or `null` if no images were extracted. */
+  get mediaDir() {
+    return this.mediaContext.totalImages > 0 ? this.mediaContext.mediaDir : null;
+  }
+  /** Returns the number of slides that were actually converted. */
+  get slidesConverted() {
+    return this.convertedSlides;
+  }
+  /** Returns the total number of slides in the source presentation. */
+  get presentationSlides() {
+    return this.totalSlides;
+  }
+  /**
+   * Converts the full PPTX presentation (or a slide subset) into Markdown.
+   *
+   * The conversion pipeline:
+   * 1. Resolves the slide range and selects the target slides.
+   * 2. Processes each slide through {@link SlideProcessor}, producing markdown sections.
+   * 3. Inserts section headings when slides belong to named sections.
+   * 4. Optionally prepends YAML front-matter with document metadata.
+   * 5. Appends header/footer information if present.
+   * 6. Writes the output file if an `outputPath` was configured.
+   *
+   * @param source - The parsed PPTX data structure.
+   * @returns The complete Markdown string.
+   */
+  async convert(source) {
+    this.totalSlides = source.slides.length;
+    const { start, end } = this.resolveRange(source.slides.length);
+    const selectedSlides = source.slides.slice(start - 1, end);
+    this.convertedSlides = selectedSlides.length;
+    const slideSections = [];
+    let currentSection;
+    for (const slide of selectedSlides) {
+      const sectionLabel = slide.sectionName ?? slide.sectionId;
+      if (sectionLabel && sectionLabel !== currentSection) {
+        currentSection = sectionLabel;
+        slideSections.push(`# ${sectionLabel}`);
+      }
+      slideSections.push(
+        await this.slideProcessor.processSlide(slide, {
+          includeSpeakerNotes: this.getOptions().includeSpeakerNotes,
+          slideWidth: source.width || 960,
+          slideHeight: source.height || 540,
+          semanticMode: this.getOptions().semanticMode
+        })
+      );
+    }
+    let markdown = slideSections.join("\n\n---\n\n");
+    if (this.options.includeMetadata) {
+      const frontMatter = this.buildPptxFrontMatter(source);
+      markdown = `${frontMatter}${markdown}`;
+    }
+    const footer = this.renderHeaderFooter(source.headerFooter);
+    if (footer) {
+      markdown = `${markdown}
+
+---
+
+${footer}`;
+    }
+    markdown = markdown.endsWith("\n") ? markdown : `${markdown}
+`;
+    if (this.options.outputPath) {
+      await this.writeOutput(markdown, this.options.outputPath);
+    }
+    return markdown;
+  }
+  /**
+   * Registers all element-type processors into the internal registry.
+   * Each processor handles one or more {@link PptxElement} types
+   * (text, image, table, chart, etc.).
+   */
+  registerProcessors() {
+    this.registry.register(new TextElementProcessor(this.textRenderer));
+    this.registry.register(new ImageElementProcessor());
+    this.registry.register(new TableElementProcessor());
+    this.registry.register(new ChartElementProcessor());
+    this.registry.register(new SmartArtElementProcessor());
+    this.registry.register(new GroupElementProcessor());
+    this.registry.register(new MediaElementProcessor());
+    this.registry.register(new OleElementProcessor());
+    this.registry.register(new InkElementProcessor());
+    this.registry.register(new FallbackElementProcessor());
+  }
+  /**
+   * Assembles a YAML front-matter block containing presentation metadata
+   * such as title, author, slide count, theme, dimensions, and more.
+   *
+   * @param source - The parsed PPTX data.
+   * @returns A YAML front-matter string (including `---` delimiters).
+   */
+  buildPptxFrontMatter(source) {
+    const meta = {
+      source: this.getOptions().sourceName,
+      format: "pptx",
+      slides: source.slides.length,
+      converted: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.addCoreProperties(meta, source.coreProperties);
+    this.addAppProperties(meta, source.appProperties);
+    if (source.width && source.height) {
+      meta.dimensions = `${source.width}x${source.height}`;
+    }
+    if (source.sections && source.sections.length > 0) {
+      meta.sections = source.sections.map((s) => s.name).join(", ");
+    }
+    this.addPresentationMeta(meta, source);
+    return this.buildFrontMatter(meta);
+  }
+  /**
+   * Populates metadata entries from OPC core properties (title, author, subject, etc.).
+   *
+   * @param meta - The metadata dictionary to populate.
+   * @param props - Core document properties from the PPTX file.
+   */
+  addCoreProperties(meta, props) {
+    if (!props) {
+      return;
+    }
+    if (props.title) {
+      meta.title = props.title;
+    }
+    if (props.creator) {
+      meta.author = props.creator;
+    }
+    if (props.subject) {
+      meta.subject = props.subject;
+    }
+    if (props.description) {
+      meta.description = props.description;
+    }
+    if (props.category) {
+      meta.category = props.category;
+    }
+    if (props.lastModifiedBy) {
+      meta.lastModifiedBy = props.lastModifiedBy;
+    }
+    if (props.revision) {
+      meta.revision = props.revision;
+    }
+  }
+  /**
+   * Populates metadata entries from application-level properties
+   * (application name, editing time, word/paragraph counts).
+   *
+   * @param meta - The metadata dictionary to populate.
+   * @param props - Application properties from the PPTX file.
+   */
+  addAppProperties(meta, props) {
+    if (!props) {
+      return;
+    }
+    if (props.application) {
+      meta.application = props.application;
+    }
+    if (typeof props.totalTime === "number") {
+      meta.editingMinutes = props.totalTime;
+    }
+    if (typeof props.words === "number") {
+      meta.words = props.words;
+    }
+    if (typeof props.paragraphs === "number") {
+      meta.paragraphs = props.paragraphs;
+    }
+  }
+  /**
+   * Adds presentation-level metadata (custom properties, show type, theme,
+   * security warnings, embedded fonts, custom shows) to the front-matter dictionary.
+   *
+   * @param meta - The metadata dictionary to populate.
+   * @param source - The full parsed PPTX data.
+   */
+  addPresentationMeta(meta, source) {
+    if (source.customProperties?.length) {
+      meta.customProperties = source.customProperties.map((p) => `${p.name}=${p.value}`).join(", ");
+    }
+    const pp = source.presentationProperties;
+    if (pp) {
+      if (pp.showType) {
+        meta.showType = pp.showType;
+      }
+      if (pp.loopContinuously) {
+        meta.loopContinuously = "true";
+      }
+      if (pp.advanceMode) {
+        meta.advanceMode = pp.advanceMode;
+      }
+      if (pp.showWithNarration) {
+        meta.narration = "enabled";
+      }
+      if (pp.showWithAnimation === false) {
+        meta.animation = "disabled";
+      }
+    }
+    if (source.theme?.name) {
+      meta.theme = source.theme.name;
+      if (source.theme.fontScheme) {
+        const major = source.theme.fontScheme.majorFont?.latin;
+        const minor = source.theme.fontScheme.minorFont?.latin;
+        if (major || minor) {
+          meta.fonts = [major, minor].filter(Boolean).join(", ");
+        }
+      }
+    }
+    if (source.isPasswordProtected) {
+      meta.warning_passwordProtected = "\u26A0 yes";
+    }
+    if (source.hasMacros) {
+      meta.warning_macros = "\u26A0 yes";
+    }
+    if (source.embeddedFonts?.length) {
+      meta.embeddedFonts = source.embeddedFonts.map((f) => f.name).join(", ");
+    }
+    if (source.customShows?.length) {
+      meta.customShows = source.customShows.map((s) => s.name).join(", ");
+    }
+  }
+  /**
+   * Renders the presentation-level header/footer settings (header text,
+   * footer text, date/time, slide numbers) into a pipe-delimited markdown string.
+   *
+   * @param hf - Header/footer configuration from the presentation.
+   * @returns A formatted string, or an empty string if no header/footer data is present.
+   */
+  renderHeaderFooter(hf) {
+    if (!hf) {
+      return "";
+    }
+    const parts = [];
+    if (hf.hasHeader && hf.headerText) {
+      parts.push(`**Header:** ${hf.headerText}`);
+    }
+    if (hf.hasFooter && hf.footerText) {
+      parts.push(`**Footer:** ${hf.footerText}`);
+    }
+    if (hf.hasDateTime && hf.dateTimeText) {
+      parts.push(`**Date/Time:** ${hf.dateTimeText}`);
+    }
+    if (hf.hasSlideNumber) {
+      parts.push("**Slide Numbers:** enabled");
+    }
+    if (hf.dateTimeAuto && hf.dateFormat) {
+      parts.push(`**Date Format:** ${hf.dateFormat}`);
+    }
+    return parts.join(" | ");
+  }
+  /**
+   * Resolves and clamps the user-specified slide range to valid bounds.
+   * Defaults to the full deck if no range is configured.
+   *
+   * @param totalSlides - Total number of slides in the presentation.
+   * @returns A 1-based `{ start, end }` range guaranteed to be within bounds.
+   */
+  resolveRange(totalSlides) {
+    const range = this.getOptions().slideRange;
+    const start = Math.max(1, Math.min(range?.start ?? 1, totalSlides));
+    const end = Math.max(start, Math.min(range?.end ?? totalSlides, totalSlides));
+    return { start, end };
+  }
+  /** Casts the base `options` to the PPTX-specific options type. */
+  getOptions() {
+    return this.options;
+  }
+};
+
+// src/converter/SvgExporter.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+function escXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function attrs(map) {
+  let out = "";
+  for (const [k, v] of Object.entries(map)) {
+    if (v !== void 0 && v !== "") {
+      out += ` ${k}="${escXml(String(v))}"`;
+    }
+  }
+  return out;
+}
+function resolveDefaults(opts) {
+  return {
+    defaultFontFamily: opts?.defaultFontFamily ?? "Arial",
+    defaultFontSize: opts?.defaultFontSize ?? 18
+  };
+}
+var _markerIdCounter = 0;
+function arrowMarkerDef(color) {
+  const id = `arrow_${++_markerIdCounter}`;
+  const svg = `<marker id="${id}" markerWidth="10" markerHeight="7" refX="10" refY="3.5" orient="auto" markerUnits="strokeWidth"><polygon points="0 0, 10 3.5, 0 7" fill="${escXml(color)}" /></marker>`;
+  return { id, svg };
+}
+function renderTransform(el) {
+  const parts = [];
+  parts.push(`translate(${el.x},${el.y})`);
+  if (el.rotation) {
+    parts.push(`rotate(${el.rotation},${el.width / 2},${el.height / 2})`);
+  }
+  const flipX = "flipHorizontal" in el && el.flipHorizontal;
+  const flipY = "flipVertical" in el && el.flipVertical;
+  if (flipX || flipY) {
+    parts.push(`translate(${flipX ? el.width : 0},${flipY ? el.height : 0})`);
+    parts.push(`scale(${flipX ? -1 : 1},${flipY ? -1 : 1})`);
+  }
+  return parts.join(" ");
+}
+function renderText(el, defaults) {
+  if (el.type !== "text" && el.type !== "shape" && el.type !== "connector") {
+    return "";
+  }
+  const text = el.text;
+  if (!text) {
+    return "";
+  }
+  const segments = el.textSegments;
+  const style = el.textStyle;
+  const fontFamily = style?.fontFamily ?? defaults.defaultFontFamily;
+  const fontSize = style?.fontSize ?? defaults.defaultFontSize;
+  const color = style?.color ?? "#000000";
+  const align = style?.align ?? "left";
+  let textAnchor = "start";
+  let textX = 4;
+  if (align === "center") {
+    textAnchor = "middle";
+    textX = el.width / 2;
+  } else if (align === "right") {
+    textAnchor = "end";
+    textX = el.width - 4;
+  }
+  if (segments && segments.length > 0) {
+    let svg2 = `<text${attrs({
+      x: textX,
+      "text-anchor": textAnchor,
+      "font-family": fontFamily,
+      "font-size": fontSize,
+      fill: color
+    })}>`;
+    let dy = fontSize * 1.2;
+    let isFirstSegment = true;
+    for (const seg of segments) {
+      if (seg.isParagraphBreak) {
+        dy = fontSize * 1.2;
+        isFirstSegment = true;
+        continue;
+      }
+      if (!seg.text) {
+        continue;
+      }
+      const segStyle = seg.style;
+      const segAttrs = {};
+      if (isFirstSegment) {
+        segAttrs.x = textX;
+        segAttrs.dy = dy;
+        isFirstSegment = false;
+      }
+      if (segStyle.fontFamily && segStyle.fontFamily !== fontFamily) {
+        segAttrs["font-family"] = segStyle.fontFamily;
+      }
+      if (segStyle.fontSize && segStyle.fontSize !== fontSize) {
+        segAttrs["font-size"] = segStyle.fontSize;
+      }
+      if (segStyle.color && segStyle.color !== color) {
+        segAttrs.fill = segStyle.color;
+      }
+      if (segStyle.bold) {
+        segAttrs["font-weight"] = "bold";
+      }
+      if (segStyle.italic) {
+        segAttrs["font-style"] = "italic";
+      }
+      if (segStyle.underline) {
+        segAttrs["text-decoration"] = "underline";
+      }
+      svg2 += `<tspan${attrs(segAttrs)}>${escXml(seg.text)}</tspan>`;
+    }
+    svg2 += `</text>`;
+    return svg2;
+  }
+  const bold = style?.bold;
+  const italic = style?.italic;
+  const lines = text.split("\n");
+  let svg = `<text${attrs({
+    x: textX,
+    "text-anchor": textAnchor,
+    "font-family": fontFamily,
+    "font-size": fontSize,
+    fill: color,
+    "font-weight": bold ? "bold" : void 0,
+    "font-style": italic ? "italic" : void 0
+  })}>`;
+  for (let i = 0; i < lines.length; i++) {
+    svg += `<tspan${attrs({
+      x: textX,
+      dy: i === 0 ? fontSize * 1.2 : fontSize * 1.2
+    })}>${escXml(lines[i])}</tspan>`;
+  }
+  svg += `</text>`;
+  return svg;
+}
+function renderShapeBody(el) {
+  if (el.type !== "shape" && el.type !== "text") {
+    return "";
+  }
+  const shapeStyle = "shapeStyle" in el ? el.shapeStyle : void 0;
+  const shapeType = "shapeType" in el ? el.shapeType : void 0;
+  const fillColor = shapeStyle?.fillColor ?? "none";
+  const strokeColor = shapeStyle?.strokeColor ?? "none";
+  const strokeWidth = shapeStyle?.strokeWidth ?? (strokeColor !== "none" ? 1 : 0);
+  const fillMode = shapeStyle?.fillMode;
+  let fill = fillColor;
+  if (fillMode === "none") {
+    fill = "none";
+  } else if (fillMode === "gradient" && shapeStyle?.fillGradient) {
+    fill = shapeStyle.fillGradientStops?.[0]?.color ?? fillColor;
+  }
+  const fillOpacity = shapeStyle?.fillOpacity;
+  const strokeOpacity = shapeStyle?.strokeOpacity;
+  const commonAttrs = {
+    fill,
+    stroke: strokeColor,
+    "stroke-width": strokeWidth || void 0,
+    "fill-opacity": fillOpacity !== void 0 ? fillOpacity : void 0,
+    "stroke-opacity": strokeOpacity !== void 0 ? strokeOpacity : void 0
+  };
+  const pathData = "pathData" in el ? el.pathData : void 0;
+  if (pathData) {
+    return `<path${attrs({ ...commonAttrs, d: pathData })} />`;
+  }
+  switch (shapeType) {
+    case "ellipse":
+    case "oval":
+      return `<ellipse${attrs({
+        ...commonAttrs,
+        cx: el.width / 2,
+        cy: el.height / 2,
+        rx: el.width / 2,
+        ry: el.height / 2
+      })} />`;
+    case "triangle":
+    case "isoTriangle":
+      return `<polygon${attrs({
+        ...commonAttrs,
+        points: `${el.width / 2},0 ${el.width},${el.height} 0,${el.height}`
+      })} />`;
+    case "diamond":
+      return `<polygon${attrs({
+        ...commonAttrs,
+        points: `${el.width / 2},0 ${el.width},${el.height / 2} ${el.width / 2},${el.height} 0,${el.height / 2}`
+      })} />`;
+    default:
+      return `<rect${attrs({
+        ...commonAttrs,
+        width: el.width,
+        height: el.height,
+        rx: shapeType === "roundRect" ? Math.min(el.width, el.height) * 0.1 : void 0
+      })} />`;
+  }
+}
+function renderImageElement(el) {
+  if (el.type !== "image" && el.type !== "picture") {
+    return "";
+  }
+  const imageData = el.imageData;
+  if (!imageData) {
+    return `<rect${attrs({ width: el.width, height: el.height, fill: "#E0E0E0", stroke: "#999", "stroke-width": 1 })} /><text${attrs({ x: el.width / 2, y: el.height / 2, "text-anchor": "middle", "font-size": 12, fill: "#666" })}>image</text>`;
+  }
+  return `<image${attrs({
+    width: el.width,
+    height: el.height,
+    preserveAspectRatio: "none"
+  })} href="${escXml(imageData)}" />`;
+}
+function renderConnector(el, defs) {
+  if (el.type !== "connector") {
+    return "";
+  }
+  const shapeStyle = el.shapeStyle;
+  const strokeColor = shapeStyle?.strokeColor ?? "#000000";
+  const strokeWidth = shapeStyle?.strokeWidth ?? 1;
+  let markerStart;
+  let markerEnd;
+  if (shapeStyle?.connectorStartArrow && shapeStyle.connectorStartArrow !== "none") {
+    const m = arrowMarkerDef(strokeColor);
+    defs.push(m.svg);
+    markerStart = `url(#${m.id})`;
+  }
+  if (shapeStyle?.connectorEndArrow && shapeStyle.connectorEndArrow !== "none") {
+    const m = arrowMarkerDef(strokeColor);
+    defs.push(m.svg);
+    markerEnd = `url(#${m.id})`;
+  }
+  return `<line${attrs({
+    x1: 0,
+    y1: 0,
+    x2: el.width,
+    y2: el.height,
+    stroke: strokeColor,
+    "stroke-width": strokeWidth,
+    "marker-start": markerStart,
+    "marker-end": markerEnd
+  })} />`;
+}
+function renderTable(el, defaults) {
+  if (el.type !== "table") {
+    return "";
+  }
+  const tableData = el.tableData;
+  if (!tableData || !tableData.rows.length) {
+    return `<rect${attrs({ width: el.width, height: el.height, fill: "#F0F0F0", stroke: "#CCC", "stroke-width": 1 })} />`;
+  }
+  const cols = tableData.columnWidths;
+  const numRows = tableData.rows.length;
+  const rowHeight = el.height / numRows;
+  let svg = "";
+  let yOffset = 0;
+  for (const row of tableData.rows) {
+    const h = row.height ?? rowHeight;
+    let xOffset = 0;
+    for (let ci = 0; ci < row.cells.length; ci++) {
+      const cell = row.cells[ci];
+      if (cell.vMerge || cell.hMerge) {
+        xOffset += (cols[ci] ?? 0) * el.width;
+        continue;
+      }
+      const cellWidth = (cols[ci] ?? 1 / row.cells.length) * el.width * (cell.gridSpan ?? 1);
+      const bgColor = cell.style?.backgroundColor ?? "none";
+      const borderColor = cell.style?.borderColor ?? "#CCCCCC";
+      const textColor = cell.style?.color ?? "#000000";
+      const fontSize = cell.style?.fontSize ?? defaults.defaultFontSize;
+      const bold = cell.style?.bold;
+      svg += `<rect${attrs({
+        x: xOffset,
+        y: yOffset,
+        width: cellWidth,
+        height: h,
+        fill: bgColor,
+        stroke: borderColor,
+        "stroke-width": 0.5
+      })} />`;
+      if (cell.text) {
+        svg += `<text${attrs({
+          x: xOffset + 4,
+          y: yOffset + h / 2,
+          "dominant-baseline": "central",
+          "font-family": defaults.defaultFontFamily,
+          "font-size": fontSize,
+          fill: textColor,
+          "font-weight": bold ? "bold" : void 0
+        })}>${escXml(cell.text)}</text>`;
+      }
+      xOffset += cellWidth;
+    }
+    yOffset += h;
+  }
+  return svg;
+}
+function renderGroup(el, defaults, defs) {
+  if (el.type !== "group") {
+    return "";
+  }
+  let inner = "";
+  for (const child of el.children) {
+    inner += renderElement(child, defaults, defs);
+  }
+  return inner;
+}
+function renderInk(el) {
+  if (el.type !== "ink") {
+    return "";
+  }
+  let svg = "";
+  for (let i = 0; i < el.inkPaths.length; i++) {
+    const path = el.inkPaths[i];
+    const color = el.inkColors?.[i] ?? "#000000";
+    const width = el.inkWidths?.[i] ?? 1;
+    const opacity = el.inkOpacities?.[i];
+    svg += `<path${attrs({
+      d: path,
+      fill: "none",
+      stroke: color,
+      "stroke-width": width,
+      "stroke-opacity": opacity,
+      "stroke-linecap": "round"
+    })} />`;
+  }
+  return svg;
+}
+function renderPlaceholder(el) {
+  return `<rect${attrs({
+    width: el.width,
+    height: el.height,
+    fill: "#F5F5F5",
+    stroke: "#CCCCCC",
+    "stroke-width": 1,
+    "stroke-dasharray": "4 2"
+  })} /><text${attrs({
+    x: el.width / 2,
+    y: el.height / 2,
+    "text-anchor": "middle",
+    "dominant-baseline": "central",
+    "font-family": "Arial",
+    "font-size": 11,
+    fill: "#999999"
+  })}>${escXml(el.type)}</text>`;
+}
+function renderElement(el, defaults, defs) {
+  if (el.hidden) {
+    return "";
+  }
+  const transform = renderTransform(el);
+  const opacity = el.opacity;
+  let inner = "";
+  switch (el.type) {
+    case "text":
+      inner = renderShapeBody(el) + renderText(el, defaults);
+      break;
+    case "shape":
+      inner = renderShapeBody(el) + renderText(el, defaults);
+      break;
+    case "connector":
+      inner = renderConnector(el, defs);
+      break;
+    case "image":
+    case "picture":
+      inner = renderImageElement(el);
+      break;
+    case "table":
+      inner = renderTable(el, defaults);
+      break;
+    case "group":
+      inner = renderGroup(el, defaults, defs);
+      break;
+    case "ink":
+      inner = renderInk(el);
+      break;
+    case "chart":
+    case "smartArt":
+    case "ole":
+    case "media":
+    case "contentPart":
+    case "zoom":
+    case "model3d":
+    case "unknown":
+      inner = renderPlaceholder(el);
+      break;
+  }
+  if (!inner) {
+    return "";
+  }
+  return `<g${attrs({
+    transform,
+    opacity: opacity !== void 0 && opacity < 1 ? opacity : void 0
+  })}>${inner}</g>`;
+}
+function renderBackground(slide, width, height) {
+  if (slide.backgroundImage) {
+    return `<rect${attrs({ width, height, fill: "#FFFFFF" })} /><image${attrs({
+      width,
+      height,
+      preserveAspectRatio: "xMidYMid slice"
+    })} href="${escXml(slide.backgroundImage)}" />`;
+  }
+  const fill = slide.backgroundColor ?? "#FFFFFF";
+  return `<rect${attrs({ width, height, fill })} />`;
+}
+var SvgExporter = class _SvgExporter {
+  /**
+   * Export a single slide to an SVG XML string.
+   *
+   * @param slide  - The parsed slide.
+   * @param width  - SVG viewport width (pixels).
+   * @param height - SVG viewport height (pixels).
+   * @param options - Optional export settings.
+   * @returns A complete SVG document as a string.
+   */
+  static exportSlide(slide, width, height, options) {
+    _markerIdCounter = 0;
+    const defaults = resolveDefaults(options);
+    const defs = [];
+    let body = renderBackground(slide, width, height);
+    for (const el of slide.elements) {
+      body += renderElement(el, defaults, defs);
+    }
+    let defsBlock = "";
+    if (defs.length) {
+      defsBlock = `<defs>${defs.join("")}</defs>`;
+    }
+    return `<svg${attrs({
+      xmlns: SVG_NS,
+      "xmlns:xlink": XLINK_NS,
+      viewBox: `0 0 ${width} ${height}`,
+      width,
+      height
+    })}>${defsBlock}${body}</svg>`;
+  }
+  /**
+   * Export all (or selected) slides to SVG XML strings.
+   *
+   * @param data    - The fully parsed PPTX data.
+   * @param options - Optional export settings.
+   * @returns An array of SVG strings (one per exported slide).
+   */
+  static exportAll(data, options) {
+    const results = [];
+    const includeHidden = options?.includeHidden ?? false;
+    for (let i = 0; i < data.slides.length; i++) {
+      if (options?.slideIndices && !options.slideIndices.includes(i)) {
+        continue;
+      }
+      const slide = data.slides[i];
+      if (slide.hidden && !includeHidden) {
+        continue;
+      }
+      results.push(_SvgExporter.exportSlide(slide, data.width, data.height, options));
+    }
+    return results;
+  }
+};
+
+exports.DocumentConverter = DocumentConverter;
+exports.MediaContext = MediaContext;
+exports.PptxMarkdownConverter = PptxMarkdownConverter;
+exports.SlideMetadataRenderer = SlideMetadataRenderer;
+exports.SlideProcessor = SlideProcessor;
+exports.SvgExporter = SvgExporter;
+exports.dataUrlToMediaBytes = dataUrlToMediaBytes;
+exports.deriveOutputPath = deriveOutputPath;
+exports.generateMediaFilename = generateMediaFilename;
+exports.getDirectory = getDirectory;
+exports.normalizePath = normalizePath;