Slides

// Copyright (c) OpenAI. All rights reserved.
"use strict";

const fs = require("fs");
const Prism = require("prismjs");
let THEME_MAP;

function loadPrismLanguage(lang) {
  const normalized = String(lang || "plaintext").toLowerCase();
  const known = new Set([
    "markup",
    "html",
    "xml",
    "svg",
    "mathml",
    "css",
    "clike",
    "javascript",
    "js",
    "typescript",
    "ts",
    "python",
    "py",
    "bash",
    "sh",
    "json",
    "yaml",
    "yml",
  ]);
  const map = {
    js: "javascript",
    ts: "typescript",
    py: "python",
    sh: "bash",
    yml: "yaml",
    html: "markup",
    xml: "markup",
  };
  const id = map[normalized] || normalized;
  if (!Prism.languages[id]) {
    try {
      require(`prismjs/components/prism-${id}`);
    } catch (_e) {}
  }
  return Prism.languages[id] || Prism.languages.plain || {};
}

function buildThemeMap(themeCssModule = "prismjs/themes/prism-okaidia.css") {
  try {
    const css = fs.readFileSync(require.resolve(themeCssModule), "utf8");
    return Object.fromEntries(
      [
        ...css.matchAll(
          /\.token\.([\w-]+)[^{]*\{[^}]*color:\s*([^;\s]+)[^}]*\}/g
        ),
      ].map(([, t, c]) => [t, c.replace(/#|!important/g, "").trim()])
    );
  } catch (err) {
    return { plain: "FFFFFF", comment: "999999" };
  }
}

function getThemeMap() {
  if (!THEME_MAP) THEME_MAP = buildThemeMap();
  return THEME_MAP;
}

function run(text, type = "plain") {
  const theme = getThemeMap();
  return {
    text,
    options: {
      fontFace: "Consolas",
      color: theme[type] || theme.plain || "FFFFFF",
      fontSize: 14,
    },
  };
}

function tokensToRuns(tokens) {
  return tokens.flatMap((t) =>
    typeof t === "string"
      ? [run(t)]
      : Array.isArray(t.content)
      ? tokensToRuns(t.content)
      : [run(t.content, t.type)]
  );
}

function codeToRuns(code, lang) {
  const grammar = loadPrismLanguage(lang);
  const lines = String(code || "").split("\n");
  const pad = lines.length.toString().length;
  return lines.flatMap((line, i) => [
    run(`${(i + 1).toString().padStart(pad, " ")} `, "comment"),
    ...tokensToRuns(Prism.tokenize(line, grammar)),
    ...(i < lines.length - 1 ? [run("\n")] : []),
  ]);
}

module.exports = {
  codeToRuns,
  buildThemeMap,
};

// Copyright (c) OpenAI. All rights reserved.
"use strict";

const fs = require("fs");

// Accept either a filesystem path, a data URI, raw SVG string, or a Buffer
// and normalize to a Buffer for type/size probing.
function readInputAsBuffer(source) {
  if (!source) throw new Error("Image source is empty");
  if (Buffer.isBuffer(source)) return { buffer: source, type: "buffer" };
  if (typeof source === "string") {
    // data URI (we primarily emit base64 data URIs for SVG via helpers)
    if (source.startsWith("data:")) {
      const type = "dataUri";
      const comma = source.indexOf(",");
      const payload = comma !== -1 ? source.slice(comma + 1) : source;
      // Our helpers use base64; if not, try URI decode then treat as raw text
      try {
        return { buffer: Buffer.from(payload, "base64"), type: type };
      } catch (_e) {
        try {
          return {
            buffer: Buffer.from(decodeURIComponent(payload), "utf8"),
            type: type,
          };
        } catch (_e2) {
          return { buffer: Buffer.from(payload, "utf8"), type: type };
        }
      }
    }
    // Raw inline SVG string
    if (source.includes("<svg")) {
      return { buffer: Buffer.from(source, "utf8"), type: "rawSvg" };
    }
    // Treat as filesystem path
    return { buffer: fs.readFileSync(source), type: "path" };
  }
  throw new Error("Unsupported image source type");
}

function isPng(buf) {
  return (
    buf.length >= 24 &&
    buf[0] === 0x89 &&
    buf[1] === 0x50 &&
    buf[2] === 0x4e &&
    buf[3] === 0x47 &&
    buf[4] === 0x0d &&
    buf[5] === 0x0a &&
    buf[6] === 0x1a &&
    buf[7] === 0x0a
  );
}

function isJpeg(buf) {
  return (
    buf.length > 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff
  );
}

function isGif(buf) {
  return (
    buf.length >= 10 &&
    buf[0] === 0x47 &&
    buf[1] === 0x49 &&
    buf[2] === 0x46 &&
    buf[3] === 0x38 &&
    (buf[4] === 0x39 || buf[4] === 0x37) &&
    buf[5] === 0x61
  );
}

function isWebp(buf) {
  return (
    buf.length >= 16 &&
    buf[0] === 0x52 &&
    buf[1] === 0x49 &&
    buf[2] === 0x46 &&
    buf[3] === 0x46 &&
    buf[8] === 0x57 &&
    buf[9] === 0x45 &&
    buf[10] === 0x42 &&
    buf[11] === 0x50
  );
}

function isSvg(buf) {
  const head = buf.slice(0, 200).toString("utf8");
  return head.includes("<svg");
}

function readPngSize(buf) {
  // IHDR chunk: width/height at offset 16, big-endian
  const width = buf.readUInt32BE(16);
  const height = buf.readUInt32BE(20);
  return { width, height, type: "png" };
}

function readGifSize(buf) {
  const width = buf.readUInt16LE(6);
  const height = buf.readUInt16LE(8);
  return { width, height, type: "gif" };
}

function readWebpSize(buf) {
  // Handle VP8X, VP8L, VP8
  // Reference: https://developers.google.com/speed/webp/docs/riff_container
  const riffSize = buf.readUInt32LE(4) + 8;
  let offset = 12; // start of first chunk
  while (offset + 8 <= riffSize && offset + 8 <= buf.length) {
    const chunkTag = buf.slice(offset, offset + 4).toString("ascii");
    const chunkSize = buf.readUInt32LE(offset + 4);
    if (chunkTag === "VP8X") {
      // Canvas size stored at bytes 12..17 (6 bytes), 24 bits each minus 1
      const wMinus1 = buf.readUIntLE(offset + 12, 3);
      const hMinus1 = buf.readUIntLE(offset + 15, 3);
      return { width: wMinus1 + 1, height: hMinus1 + 1, type: "webp" };
    }
    if (chunkTag === "VP8 ") {
      // Lossy bitstream: frame header at start of data
      // Parse minimally for width/height
      const start = offset + 8;
      if (start + 10 < buf.length) {
        const width = buf.readUInt16LE(start + 6) & 0x3fff;
        const height = buf.readUInt16LE(start + 8) & 0x3fff;
        return { width, height, type: "webp" };
      }
    }
    if (chunkTag === "VP8L") {
      // Lossless bitstream: 14-bit width/height encoded
      const start = offset + 8;
      if (start + 5 <= buf.length) {
        const b0 = buf[start + 1];
        const b1 = buf[start + 2];
        const b2 = buf[start + 3];
        const b3 = buf[start + 4];
        const width = 1 + (((b1 & 0x3f) << 8) | b0);
        const height =
          1 + (((b3 & 0xf) << 10) | (b2 << 2) | ((b1 & 0xc0) >> 6));
        return { width, height, type: "webp" };
      }
    }
    offset += 8 + ((chunkSize + 1) & ~1); // chunks are padded to even size
  }
  throw new Error("Unsupported WEBP variant for size detection");
}

function readJpegSize(buf) {
  let offset = 2;
  while (offset < buf.length) {
    if (buf[offset] !== 0xff) {
      offset++;
      continue;
    }
    const marker = buf[offset + 1];
    // SOF0..SOF3, SOF5..SOF7, SOF9..SOF11, SOF13..SOF15
    if (
      (marker >= 0xc0 && marker <= 0xc3) ||
      (marker >= 0xc5 && marker <= 0xc7) ||
      (marker >= 0xc9 && marker <= 0xcb) ||
      (marker >= 0xcd && marker <= 0xcf)
    ) {
      const blockLength = buf.readUInt16BE(offset + 2);
      const height = buf.readUInt16BE(offset + 5);
      const width = buf.readUInt16BE(offset + 7);
      return { width, height, type: "jpeg" };
    }
    const blockLength = buf.readUInt16BE(offset + 2);
    if (!Number.isFinite(blockLength) || blockLength < 2) break;
    offset += 2 + blockLength;
  }
  throw new Error("JPEG size not found");
}

function parseSvgSize(buf) {
  const text = buf.toString("utf8");
  const a = text.indexOf("<svg");
  const b = text.indexOf("</svg>");
  const inner = a !== -1 && b !== -1 ? text.slice(a, b + 6) : text;
  const widthMatch = inner.match(/\bwidth\s*=\s*"([^"]+)"/i);
  const heightMatch = inner.match(/\bheight\s*=\s*"([^"]+)"/i);
  const viewBoxMatch = inner.match(/\bviewBox\s*=\s*"([^"]+)"/i);

  function toPx(v) {
    if (!v) return null;
    const m = String(v)
      .trim()
      .match(/([0-9.]+)\s*(px|pt|em|ex|cm|mm|in|%)?/i);
    if (!m) return null;
    const n = parseFloat(m[1]);
    const unit = (m[2] || "px").toLowerCase();
    const dpi = 96;
    switch (unit) {
      case "px":
        return n;
      case "pt":
        return (n * dpi) / 72;
      case "in":
        return n * dpi;
      case "cm":
        return (n * dpi) / 2.54;
      case "mm":
        return (n * dpi) / 25.4;
      case "em":
      case "ex":
        return n * 16; // rough fallback
      default:
        return null;
    }
  }

  let widthPx = widthMatch ? toPx(widthMatch[1]) : null;
  let heightPx = heightMatch ? toPx(heightMatch[1]) : null;
  if ((widthPx == null || heightPx == null) && viewBoxMatch) {
    const parts = viewBoxMatch[1].trim().split(/\s+/).map(Number);
    if (parts.length === 4) {
      const vbw = parts[2];
      const vbh = parts[3];
      if (!widthPx && vbh) widthPx = vbw;
      if (!heightPx && vbw) heightPx = vbh;
    }
  }
  if (!widthPx || !heightPx) {
    // Fallback if sizes missing
    widthPx = widthPx || 100;
    heightPx = heightPx || 100;
  }
  return { width: widthPx, height: heightPx, type: "svg" };
}

function getImageDimensions(pathOrData) {
  const { buffer: buf, type } = readInputAsBuffer(pathOrData);
  let meta;
  if (isPng(buf)) meta = readPngSize(buf);
  else if (isJpeg(buf)) meta = readJpegSize(buf);
  else if (isGif(buf)) meta = readGifSize(buf);
  else if (isWebp(buf)) meta = readWebpSize(buf);
  else if (isSvg(buf)) meta = parseSvgSize(buf);
  else {
    const suffix =
      type === "path" && typeof pathOrData === "string"
        ? ` (path: ${pathOrData})`
        : "";
    throw new Error("Unsupported image format for provided source" + suffix);
  }

  const aspectRatio =
    meta.width > 0 && meta.height > 0 ? meta.width / meta.height : 1;
  return {
    width: meta.width,
    height: meta.height,
    aspectRatio,
    type: meta.type,
  };
}

function imageSizingCrop(source, x, y, w, h, cx, cy, cw, ch) {
  const { aspectRatio } = getImageDimensions(source);
  const boxAspect = w / h;

  if (
    cx === undefined ||
    cy === undefined ||
    cw === undefined ||
    ch === undefined
  ) {
    let cropXFrac, cropYFrac, cropWFrac, cropHFrac;
    if (aspectRatio >= boxAspect) {
      cropHFrac = 1;
      cropWFrac = boxAspect / aspectRatio;
      cropXFrac = (1 - cropWFrac) / 2;
      cropYFrac = 0;
    } else {
      cropWFrac = 1;
      cropHFrac = aspectRatio / boxAspect;
      cropXFrac = 0;
      cropYFrac = (1 - cropHFrac) / 2;
    }
    cx = cropXFrac;
    cy = cropYFrac;
    cw = cropWFrac;
    ch = cropHFrac;
  }

  let virtualW = w / cw;
  let virtualH = virtualW / aspectRatio;
  const eps = 1e-6;
  if (Math.abs(virtualH * ch - h) > eps) {
    virtualH = h / ch;
    virtualW = virtualH * aspectRatio;
  }

  const cropXIn = cx * virtualW;
  const cropYIn = cy * virtualH;
  return {
    x,
    y,
    w: virtualW,
    h: virtualH,
    sizing: {
      type: "crop",
      x: cropXIn,
      y: cropYIn,
      w: w,
      h: h,
    },
  };
}

function imageSizingContain(source, x, y, w, h) {
  const { aspectRatio } = getImageDimensions(source);
  let w2, h2;
  const boxAspect = w / h;
  if (aspectRatio >= boxAspect) {
    w2 = w;
    h2 = w2 / aspectRatio;
  } else {
    h2 = h;
    w2 = h2 * aspectRatio;
  }
  return {
    x: x + (w - w2) / 2,
    y: y + (h - h2) / 2,
    w: w2,
    h: h2,
  };
}

module.exports = {
  getImageDimensions,
  imageSizingCrop,
  imageSizingContain,
};

// Copyright (c) OpenAI. All rights reserved.
"use strict";

const VERSION = "1.2.0";

const text = require("./text");
const image = require("./image");
const svg = require("./svg");
const latex = require("./latex");
const code = require("./code");
const layout = require("./layout");
const layoutBuilders = require("./layout_builders");
const util = require("./util");

module.exports = {
  VERSION,
  // text layout
  ...text,
  // images
  ...image,
  // svg helpers
  ...svg,
  // LaTeX -> SVG
  ...latex,
  // code block -> pptx text runs
  ...code,
  // slide layout analyzers
  ...layout,
  // slide layout builders
  ...layoutBuilders,
  // text layout helpers and utilities
  ...util,
};

// Copyright (c) OpenAI. All rights reserved.
"use strict";

let _mathjax;
let _adaptor;
let _doc;

function ensureMathJax() {
  if (_mathjax && _adaptor && _doc) return;
  try {
    const { mathjax } = require("mathjax-full/js/mathjax.js");
    const { TeX } = require("mathjax-full/js/input/tex.js");
    const { SVG } = require("mathjax-full/js/output/svg.js");
    const { liteAdaptor } = require("mathjax-full/js/adaptors/liteAdaptor.js");
    const { RegisterHTMLHandler } = require("mathjax-full/js/handlers/html.js");
    const { AllPackages } = require("mathjax-full/js/input/tex/AllPackages.js");

    _adaptor = liteAdaptor();
    RegisterHTMLHandler(_adaptor);
    const tex = new TeX({ packages: AllPackages });
    const out = new SVG({ fontCache: "local" });
    _doc = mathjax.document("", { InputJax: tex, OutputJax: out });
    _mathjax = mathjax;
  } catch (err) {
    throw new Error(
      "mathjax-full is not installed. Run `npm i mathjax-full` or avoid latexToSvgDataUri()."
    );
  }
}

function latexToSvgDataUri(latex, display = true) {
  ensureMathJax();
  const html = _adaptor.outerHTML(_doc.convert(latex, { display }));
  const a = html.indexOf("<svg");
  const b = html.indexOf("</svg>");
  let svg = a !== -1 && b !== -1 ? html.slice(a, b + 6) : html;
  svg = svg.replace(/<\?xml[^>]*>/g, "");
  if (!/xmlns=\"http:\/\/www\.w3\.org\/2000\/svg\"/.test(svg)) {
    svg = svg.replace(/<svg /, '<svg xmlns="http://www.w3.org/2000/svg" ');
  }
  svg = svg.replace(/(width|height)=\"([0-9.]+)(ex|em)\"/g, (_m, attr, num) => {
    const px = Math.round(parseFloat(num) * 8.5);
    return `${attr}="${px}px"`;
  });
  svg = svg.replace(/currentColor/g, "#000000");
  return "data:image/svg+xml;base64," + Buffer.from(svg).toString("base64");
}

module.exports = {
  latexToSvgDataUri,
};

// Copyright (c) OpenAI. All rights reserved.
"use strict";

const { calcTextBox, autoFontSize } = require("./text");
const { imageSizingCrop, imageSizingContain } = require("./image");
const { getSlideDimensions } = require("./layout");

module.exports = {
  addImageTextCard,
  addCardRow,
  addThreeLevelTree,
};

function addImageTextCard(slide, opts = {}) {
  const x = toNumberOr(opts.x, 0);
  const y = toNumberOr(opts.y, 0);
  const w = toNumberOr(opts.width, 3.0);
  const gap = toNumberOr(opts.gap, 0.15);
  const image = opts.image || {};
  const text = opts.text || "";
  const textBox = opts.textBox || {};

  const boxH = toNumberOr(image.boxHeight, 2.2);
  const sizing = (image.sizing || "crop").toLowerCase();
  let imgPlacement;
  if (image.path || image.data) {
    const base = image.path ? { path: image.path } : { data: image.data };
    if (sizing === "contain") {
      imgPlacement = imageSizingContain(
        image.path || image.data,
        x,
        y,
        w,
        boxH
      );
      slide.addImage({ ...base, ...imgPlacement });
    } else {
      const c = image.crop || {};
      imgPlacement = imageSizingCrop(
        image.path || image.data,
        x,
        y,
        w,
        boxH,
        c.cx,
        c.cy,
        c.cw,
        c.ch
      );
      slide.addImage({ ...base, ...imgPlacement });
    }
  }

  const textY = y + boxH + gap;
  const fontSize = toNumberOr(textBox.fontSize, 14);
  const fontFaceRaw = textBox.fontFace;
  const fontFace =
    typeof fontFaceRaw === "string" && fontFaceRaw.trim().length > 0
      ? fontFaceRaw.trim()
      : null;
  if (!fontFace) {
    throw new Error(
      "addImageTextCard(): textBox.fontFace is required for text measurement."
    );
  }
  let hText;
  let textOptions;

  if (textBox.h != null && Number.isFinite(toNumberOr(textBox.h, NaN))) {
    // Layout-first: caller fixed the box height, so adjust font size to fit via autoFontSize.
    const fixedH = toNumberOr(textBox.h, 0);
    const baseOpts = {
      x,
      y: textY,
      w,
      h: fixedH,
      mode: textBox.mode || "auto",
      fontSize,
      minFontSize: textBox.minFontSize,
      maxFontSize: textBox.maxFontSize,
      margin: textBox.margin,
      paraSpaceAfter: textBox.paraSpaceAfter,
    };
    const autoOpts = autoFontSize(text, fontFace, baseOpts);
    hText = fixedH;
    textOptions = {
      ...autoOpts,
      fontFace,
      color: textBox.color,
      align: textBox.align,
      valign: textBox.valign || "top",
      fill: opts.background,
    };
  } else {
    // Content-first: fixed font size, let calcTextBox derive the required height.
    const layout = calcTextBox(fontSize, {
      text,
      w,
      fontFace,
      margin: textBox.margin,
      paraSpaceAfter: textBox.paraSpaceAfter,
    });
    hText = layout.h;
    textOptions = {
      x,
      y: textY,
      w,
      h: hText,
      fontFace,
      fontSize,
      color: textBox.color,
      align: textBox.align,
      valign: textBox.valign || "top",
      paraSpaceAfter: textBox.paraSpaceAfter,
      margin: textBox.margin,
      fill: opts.background,
    };
  }

  slide.addText(text, textOptions);

  return {
    x,
    y,
    w,
    image: {
      x: imgPlacement?.x ?? x,
      y,
      w: imgPlacement?.w ?? w,
      h: imgPlacement?.h ?? boxH,
    },
    text: { x, y: textY, w, h: hText },
  };
}

function addCardRow(slide, region, cards = [], options = {}) {
  const rx = toNumberOr(region.x, 0.4);
  const ry = toNumberOr(region.y, 1.6);
  const slideWidth = getSlideDimensions(slide).width;
  const rw = toNumberOr(region.w, slideWidth - rx * 2);
  const gap = toNumberOr(options.gap, 0.25);
  const count = cards.length;
  if (count === 0) return [];

  let cardW;
  if (options.widthStrategy === "fixed") {
    cardW = toNumberOr(
      options.cardWidth,
      rw / count - (gap * (count - 1)) / count
    );
  } else {
    cardW = (rw - gap * (count - 1)) / count;
  }

  const totalWidth = cardW * count + gap * (count - 1);
  const align = options.align || "left";
  const ox =
    align === "center"
      ? (rw - totalWidth) / 2
      : align === "right"
      ? rw - totalWidth
      : 0;

  const placements = [];
  for (let i = 0; i < count; i++) {
    const x = rx + ox + i * (cardW + gap);
    placements.push(
      addImageTextCard(slide, { ...cards[i], x, y: ry, width: cardW })
    );
  }
  return placements;
}

function addThreeLevelTree(slide, opts = {}) {
  const slideWidth = getSlideDimensions(slide).width;
  const cx = toNumberOr(opts.centerX, slideWidth / 2);
  const topY = toNumberOr(opts.topY, 1.6);

  const rootW = toNumberOr(opts.root?.w, 3.3333333);
  const rootH = toNumberOr(opts.root?.h, 0.93333333);
  const rootX = cx - rootW / 2;
  const rootFontFaceRaw = opts.root?.fontFace;
  const rootFontFace =
    typeof rootFontFaceRaw === "string" && rootFontFaceRaw.trim().length > 0
      ? rootFontFaceRaw.trim()
      : null;
  if (!rootFontFace) {
    throw new Error(
      "addThreeLevelTree(): opts.root.fontFace is required for text measurement."
    );
  }
  const rootFontSize = toNumberOr(opts.root?.fontSize, 16);
  const rootText = opts.root?.text || "";
  const rootTextOpts = autoFontSize(rootText, rootFontFace, {
    x: rootX,
    y: topY,
    w: rootW,
    h: rootH,
    mode: opts.root?.mode || "shrink",
    fontSize: rootFontSize,
    minFontSize: opts.root?.minFontSize,
    maxFontSize: opts.root?.maxFontSize,
  });
  slide.addText(rootText, {
    ...rootTextOpts,
    align: "center",
    valign: "mid",
    fontFace: rootFontFace,
    color: opts.root?.color || "FFFFFF",
    fill: { color: opts.root?.fill || "0B0F1A" },
    line: { color: opts.root?.line || opts.root?.fill || "0B0F1A" },
  });

  const midLabels = Array.isArray(opts.mid?.labels) ? opts.mid.labels : [];
  const midFontFaceRaw = opts.mid?.fontFace;
  const midFontFace =
    typeof midFontFaceRaw === "string" && midFontFaceRaw.trim().length > 0
      ? midFontFaceRaw.trim()
      : null;
  if (!midFontFace) {
    throw new Error(
      "addThreeLevelTree(): opts.mid.fontFace is required for text measurement."
    );
  }
  let midW = toNumberOr(opts.mid?.w, NaN);
  const midH = toNumberOr(opts.mid?.h, rootH);
  const midY = toNumberOr(opts.mid?.y, topY + rootH + 1.2);
  const requestedSpacing = toNumberOr(opts.mid?.spacing, NaN); // center-to-center distance if provided
  const leftRightMargin = toNumberOr(opts.mid?.marginX, 0.6);
  const availableRowWidth = slideWidth - leftRightMargin * 2;
  const countMid = midLabels.length;
  const minGap = 0.4;
  if (!Number.isFinite(midW) && Number.isFinite(requestedSpacing)) {
    // Derive midW from spacing and available width
    const totalSpan = requestedSpacing * (countMid - 1) + 0; // span between first and last centers
    const maxW = Math.min(rootW, (availableRowWidth - totalSpan) / countMid);
    midW = Math.max(0.8, maxW);
  }
  if (!Number.isFinite(midW)) {
    // Fit equally within available width with minimum gaps
    midW = Math.max(
      0.8,
      (availableRowWidth - minGap * (countMid - 1)) / countMid
    );
  }
  // Compute gap to center-group horizontally without overlap
  let gap = Math.max(
    minGap,
    (availableRowWidth - midW * countMid) / Math.max(1, countMid - 1)
  );
  const totalWidth = midW * countMid + gap * (countMid - 1);
  const startLeft = cx - totalWidth / 2;
  for (let i = 0; i < midLabels.length; i++) {
    const x = startLeft + i * (midW + gap);
    const midText = midLabels[i] || "";
    const midFontSize = toNumberOr(opts.mid?.fontSize, 16);
    const midTextOpts = autoFontSize(midText, midFontFace, {
      x,
      y: midY,
      w: midW,
      h: midH,
      mode: opts.mid?.mode || "shrink",
      fontSize: midFontSize,
      minFontSize: opts.mid?.minFontSize,
      maxFontSize: opts.mid?.maxFontSize,
    });
    slide.addText(midText, {
      ...midTextOpts,
      align: "center",
      valign: "mid",
      fontFace: midFontFace,
      color: opts.mid?.color || "000000",
      fill: { color: opts.mid?.fill || "A0BEC2" },
      line: { color: opts.mid?.line || opts.mid?.fill || "A0BEC2" },
    });
    addConnector(slide, cx, topY + rootH, x + midW / 2, midY, opts.line);
  }

  const leavesPerMid = Array.isArray(opts.leaf?.labelsPerMid)
    ? opts.leaf.labelsPerMid
    : [];
  const leafFontFaceRaw = opts.leaf?.fontFace;
  const leafFontFace =
    typeof leafFontFaceRaw === "string" && leafFontFaceRaw.trim().length > 0
      ? leafFontFaceRaw.trim()
      : null;
  if (!leafFontFace) {
    throw new Error(
      "addThreeLevelTree(): opts.leaf.fontFace is required for text measurement."
    );
  }
  const leafW = toNumberOr(opts.leaf?.w, 1.05);
  const leafH = toNumberOr(opts.leaf?.h, 1.0666667);
  const leafY = toNumberOr(opts.leaf?.y, midY + midH + 1.0);
  const minLeafGap = 0.2;
  for (let i = 0; i < midLabels.length; i++) {
    const xBase = startLeft + i * (midW + gap);
    const childLabels = Array.isArray(leavesPerMid[i]) ? leavesPerMid[i] : [];
    const childCount = childLabels.length || 3;
    // Compute per-mid gap to fit children within midW without overlap
    const leafGap = Math.max(
      minLeafGap,
      (midW - childCount * leafW) / Math.max(1, childCount - 1)
    );
    const totalWidth = childCount * leafW + (childCount - 1) * leafGap;
    const leftX = xBase + (midW - totalWidth) / 2;
    for (let j = 0; j < childCount; j++) {
      const x = leftX + j * (leafW + leafGap);
      const leafText = childLabels[j] || "";
      const leafFontSize = toNumberOr(opts.leaf?.fontSize, 16);
      const leafTextOpts = autoFontSize(leafText, leafFontFace, {
        x,
        y: leafY,
        w: leafW,
        h: leafH,
        mode: opts.leaf?.mode || "shrink",
        fontSize: leafFontSize,
        minFontSize: opts.leaf?.minFontSize,
        maxFontSize: opts.leaf?.maxFontSize,
      });
      slide.addText(leafText, {
        ...leafTextOpts,
        align: "center",
        valign: "mid",
        fontFace: leafFontFace,
        color: opts.leaf?.color || "000000",
        fill: { color: opts.leaf?.fill || "A6C1EE" },
        line: { color: opts.leaf?.line || opts.leaf?.fill || "A6C1EE" },
      });
      addConnector(
        slide,
        xBase + midW / 2,
        midY + midH,
        x + leafW / 2,
        leafY,
        opts.line
      );
    }
  }
}

function addConnector(slide, x1, y1, x2, y2, line = {}) {
  const x = Math.min(x1, x2);
  const y = Math.min(y1, y2);
  slide.addShape("line", {
    x,
    y,
    w: Math.abs(x2 - x1),
    h: Math.abs(y2 - y1),
    line: { color: line.color || "000000", pt: line.pt || 1 },
    flipH: x2 < x1 ? true : undefined,
  });
}

function toNumberOr(v, fallback) {
  const n = typeof v === "string" ? parseFloat(v) : v;
  return Number.isFinite(n) ? n : fallback;
}

// Copyright (c) OpenAI. All rights reserved.
"use strict";

function inferElementType(obj) {
  if (!obj) return "unknown";
  const data = obj.data || obj.options || {};
  // Distinguish lines explicitly via type only. Many objects have a 'line' style; don't misclassify those.
  if (obj.type === "line") return "line";
  if (obj.type && typeof obj.type === "string") return obj.type;
  if (obj.text || typeof data.text === "string") return "text";
  if (data.path || obj.image) return "image";
  if (data.chartType) return "chart";
  if (data.shape || data.line) return "shape";
  if (data.mediaType) return "media";
  if (data.table || Array.isArray(data.rows)) return "table";
  if (data.smartArt) return "smartart";
  return "unknown";
}

const TEXT_OVERLAP_ERROR_THRESHOLD = 0.1;
const RECTIFY_DIRECTION_EQUALITY_TOLERANCE = 0.15;

function warnIfSlideHasOverlaps(slide, pptx, options = {}) {
  if (!slide || !Array.isArray(slide._slideObjects)) {
    console.warn("Invalid slide object passed to warnIfSlideOverlaps()");
    return;
  }
  const opts = {
    // By default, containment cases are very common (e.g., full-slide backgrounds)
    // and usually not actionable. Mute them unless explicitly requested.
    muteContainment:
      options.muteContainment !== undefined ? options.muteContainment : true,
    // Do NOT ignore lines or decorative shapes by default; users want true overlaps.
    ignoreLines:
      options.ignoreLines !== undefined ? options.ignoreLines : false,
    ignoreDecorativeShapes:
      options.ignoreDecorativeShapes !== undefined
        ? options.ignoreDecorativeShapes
        : false,
  };
  const slideIndex =
    pptx && Array.isArray(pptx._slides) ? pptx._slides.indexOf(slide) : -1;
  const slideLabel =
    slideIndex >= 0 ? `Slide ${slideIndex + 1}` : "(Unknown slide index)";
  const formatElement = (el) => {
    const cx = (el.x + el.w / 2).toFixed(3);
    const cy = (el.y + el.h / 2).toFixed(3);
    return `element ${el.index} (${el.type}, center_x=${cx}, center_y=${cy})`;
  };
  const elements = slide._slideObjects.map((obj, i) => {
    const {
      x = 0,
      y = 0,
      w = 0,
      h = 0,
      fill,
      line,
    } = obj.data || obj.options || {};
    const type = inferElementType(obj);
    const isDecorative = (() => {
      if (!opts.ignoreDecorativeShapes) return false;
      // Border rectangles used as frames: transparent fill (or fully transparent) with a stroke
      const transparency =
        typeof fill?.transparency === "number" ? fill.transparency : null;
      const hasOnlyBorder = !!line && (!fill || transparency !== null);
      const fullyTransparent = transparency !== null && transparency >= 99;
      return type === "shape" && hasOnlyBorder && fullyTransparent;
    })();
    const ignorable = (opts.ignoreLines && type === "line") || isDecorative;
    return { index: i, type, x, y, w, h, ignorable };
  });
  let overlapCount = 0;
  let containmentCount = 0;
  for (let i = 0; i < elements.length; i++) {
    const a = elements[i];
    if (a.ignorable) continue;
    for (let j = i + 1; j < elements.length; j++) {
      const b = elements[j];
      if (b.ignorable) continue;
      const comparison = compareElementPosition(slide, a.index, b.index);
      if (comparison.relation === "overlapping") {
        // Special-case: diagonal line's bounding box overlapping a rectangle is often a false positive.
        const EPS = 1e-6;
        const getBounds = (e) => ({
          x: e.x,
          y: e.y,
          x2: e.x + e.w,
          y2: e.y + e.h,
        });
        const lineRectFalsePositive = (() => {
          const oneIsLine = (a.type === "line") ^ (b.type === "line");
          if (!oneIsLine) return false;
          const line = a.type === "line" ? a : b;
          const rect = a.type === "line" ? b : a;
          // If line is diagonal, verify actual segment intersects rect; if not, ignore.
          const isDiagonal = line.w > EPS && line.h > EPS;
          const lineSeg = {
            x1: line.x,
            y1: line.y,
            x2: line.x + line.w,
            y2: line.y + line.h,
          };
          const rectB = getBounds(rect);
          const pointInRect = (px, py, rb) =>
            px >= rb.x - EPS &&
            px <= rb.x2 + EPS &&
            py >= rb.y - EPS &&
            py <= rb.y2 + EPS;
          const segsIntersect = (p1, p2, q1, q2) => {
            const cross = (ax, ay, bx, by) => ax * by - ay * bx;
            const d1x = p2.x - p1.x,
              d1y = p2.y - p1.y;
            const d2x = q2.x - q1.x,
              d2y = q2.y - q1.y;
            const denom = cross(d1x, d1y, d2x, d2y);
            if (Math.abs(denom) < EPS) {
              // Parallel: check colinearity and overlapping projections
              const crossCol = cross(q1.x - p1.x, q1.y - p1.y, d1x, d1y);
              if (Math.abs(crossCol) > EPS) return false;
              const proj = (a, b, c) =>
                Math.min(Math.max(a, b), Math.max(Math.min(a, b), c));
              const overlapX = !(
                Math.max(p1.x, p2.x) < Math.min(q1.x, q2.x) - EPS ||
                Math.max(q1.x, q2.x) < Math.min(p1.x, p2.x) - EPS
              );
              const overlapY = !(
                Math.max(p1.y, p2.y) < Math.min(q1.y, q2.y) - EPS ||
                Math.max(q1.y, q2.y) < Math.min(p1.y, p2.y) - EPS
              );
              return overlapX && overlapY;
            }
            const t = cross(q1.x - p1.x, q1.y - p1.y, d2x, d2y) / denom;
            const u = cross(q1.x - p1.x, q1.y - p1.y, d1x, d1y) / denom;
            return t >= -EPS && t <= 1 + EPS && u >= -EPS && u <= 1 + EPS;
          };
          const intersectsRect = (seg, rb) => {
            if (
              pointInRect(seg.x1, seg.y1, rb) ||
              pointInRect(seg.x2, seg.y2, rb)
            )
              return true;
            const r1 = { x: rb.x, y: rb.y },
              r2 = { x: rb.x2, y: rb.y },
              r3 = { x: rb.x2, y: rb.y2 },
              r4 = { x: rb.x, y: rb.y2 };
            const p1 = { x: seg.x1, y: seg.y1 },
              p2 = { x: seg.x2, y: seg.y2 };
            return (
              segsIntersect(p1, p2, r1, r2) ||
              segsIntersect(p1, p2, r2, r3) ||
              segsIntersect(p1, p2, r3, r4) ||
              segsIntersect(p1, p2, r4, r1)
            );
          };
          return isDiagonal && !intersectsRect(lineSeg, rectB);
        })();
        if (!lineRectFalsePositive) {
          overlapCount++;

          const severeTextOverlap = (() => {
            if (!comparison.intersection) return false;
            const exceedsThreshold = (element) =>
              element.type === "text" &&
              comparison.intersection.w >= TEXT_OVERLAP_ERROR_THRESHOLD &&
              comparison.intersection.h >= TEXT_OVERLAP_ERROR_THRESHOLD;
            return exceedsThreshold(a) || exceedsThreshold(b);
          })();
          if (severeTextOverlap) {
            const overlapW = comparison.intersection.w;
            const overlapH = comparison.intersection.h;
            let rectificationSuggestion = "";
            if (overlapW > EPS && overlapH > EPS) {
              const maxOverlap = Math.max(overlapW, overlapH);
              const diffRatio = Math.abs(overlapW - overlapH) / maxOverlap;
              const directions = [];
              // Attempt to determine the primary direction of the overlap. This is the direction
              // in which the overlap is smaller (and so requires the smallest adjustment to rectify).
              if (diffRatio <= RECTIFY_DIRECTION_EQUALITY_TOLERANCE) {
                directions.push("horizontally", "vertically");
              } else if (overlapW < overlapH) {
                directions.push("horizontally");
              } else {
                directions.push("vertically");
              }
              rectificationSuggestion = `Suggestion: reposition elements ${directions.join(
                " and "
              )}.`;
            }

            console.error(
              `❌ ${slideLabel}: Severe text overlap detected between ${formatElement(
                a
              )} and ${formatElement(
                b
              )} (overlap_horizontal=${comparison.intersection.w.toFixed(
                3
              )}, overlap_vertical=${comparison.intersection.h.toFixed(
                3
              )}). THIS MUST BE FIXED. ${rectificationSuggestion}`
            );
          } else {
            console.warn(
              `⚠️ ${slideLabel}: Overlap detected between ${formatElement(
                a
              )} and ${formatElement(b)}.`
            );
          }
        }
      } else if (comparison.relation === "contained") {
        if (!opts.muteContainment) {
          containmentCount++;
          const container = elements[comparison.containerIndex];
          const contained = elements[comparison.containedIndex];
          console.warn(
            `⚠️ ${slideLabel}: ${formatElement(
              contained
            )} is fully contained within ${formatElement(container)}`
          );
        } else {
          // Still count internally when muted? We keep for summary only when un-muted
        }
      }
    }
  }
  if (!(overlapCount === 0 && (!containmentCount || opts.muteContainment))) {
    const issues = [];
    if (overlapCount > 0) issues.push(`${overlapCount} overlapping pair(s)`);
    if (!opts.muteContainment && containmentCount > 0)
      issues.push(`${containmentCount} containment case(s)`);
    console.log(`⚠️ ${slideLabel}: Found ${issues.join(" and ")}.`);
  }
}

function compareElementPosition(slide, firstIndex, secondIndex) {
  if (!slide || !Array.isArray(slide._slideObjects)) {
    throw new Error("Invalid slide object passed to compareElementPosition()");
  }
  if (
    typeof firstIndex !== "number" ||
    typeof secondIndex !== "number" ||
    !Number.isInteger(firstIndex) ||
    !Number.isInteger(secondIndex)
  ) {
    throw new Error("Element indices must be integer values.");
  }
  const elements = slide._slideObjects;
  if (
    firstIndex < 0 ||
    firstIndex >= elements.length ||
    secondIndex < 0 ||
    secondIndex >= elements.length
  ) {
    throw new Error(
      "Element index out of bounds for compareElementPosition()."
    );
  }
  const EPS = 1e-4;
  const getBounds = (obj) => {
    const source = obj?.data || obj?.options || {};
    let x = typeof source.x === "number" ? source.x : 0;
    let y = typeof source.y === "number" ? source.y : 0;
    let w = typeof source.w === "number" ? source.w : 0;
    let h = typeof source.h === "number" ? source.h : 0;
    if (source.sizing && source.sizing.type === "crop") {
      if (typeof source.sizing.w === "number") w = source.sizing.w;
      if (typeof source.sizing.h === "number") h = source.sizing.h;
    }
    return { x, y, w, h, x2: x + w, y2: y + h };
  };
  const boundsA = getBounds(elements[firstIndex]);
  const boundsB = getBounds(elements[secondIndex]);
  const separated =
    boundsA.x2 < boundsB.x - EPS ||
    boundsB.x2 < boundsA.x - EPS ||
    boundsA.y2 < boundsB.y - EPS ||
    boundsB.y2 < boundsA.y - EPS;
  if (separated) {
    return {
      relation: "disjoint",
      containerIndex: null,
      containedIndex: null,
      aBounds: boundsA,
      bBounds: boundsB,
      intersection: null,
    };
  }
  const aContainsB =
    boundsA.x <= boundsB.x + EPS &&
    boundsA.y <= boundsB.y + EPS &&
    boundsA.x2 >= boundsB.x2 - EPS &&
    boundsA.y2 >= boundsB.y2 - EPS;
  const bContainsA =
    boundsB.x <= boundsA.x + EPS &&
    boundsB.y <= boundsA.y + EPS &&
    boundsB.x2 >= boundsA.x2 - EPS &&
    boundsB.y2 >= boundsA.y2 - EPS;
  const ix1 = Math.max(boundsA.x, boundsB.x);
  const iy1 = Math.max(boundsA.y, boundsB.y);
  const ix2 = Math.min(boundsA.x2, boundsB.x2);
  const iy2 = Math.min(boundsA.y2, boundsB.y2);
  const intersectionWidth = Math.max(0, ix2 - ix1);
  const intersectionHeight = Math.max(0, iy2 - iy1);
  const intersection =
    intersectionWidth > EPS && intersectionHeight > EPS
      ? { x: ix1, y: iy1, w: intersectionWidth, h: intersectionHeight }
      : null;
  if (aContainsB && !bContainsA) {
    return {
      relation: "contained",
      containerIndex: firstIndex,
      containedIndex: secondIndex,
      aBounds: boundsA,
      bBounds: boundsB,
      intersection,
    };
  }
  if (bContainsA && !aContainsB) {
    return {
      relation: "contained",
      containerIndex: secondIndex,
      containedIndex: firstIndex,
      aBounds: boundsA,
      bBounds: boundsB,
      intersection,
    };
  }
  if (intersection) {
    return {
      relation: "overlapping",
      containerIndex: null,
      containedIndex: null,
      aBounds: boundsA,
      bBounds: boundsB,
      intersection,
    };
  }
  return {
    relation: "touching",
    containerIndex: null,
    containedIndex: null,
    aBounds: boundsA,
    bBounds: boundsB,
    intersection: null,
  };
}

const VALID_ALIGNMENTS = new Set([
  "left",
  "right",
  "top",
  "bottom",
  "verticallyCenter",
  "horizontallyCenter",
]);

const getElementBounds = (obj) => {
  const source = obj?.data || obj?.options || {};
  let x = typeof source.x === "number" ? source.x : 0;
  let y = typeof source.y === "number" ? source.y : 0;
  let w = typeof source.w === "number" ? source.w : 0;
  let h = typeof source.h === "number" ? source.h : 0;
  // If an image is placed with crop sizing, pptxgenjs stores a larger virtual image w/h
  // and a viewport in source.sizing.{w,h}. For visual overlap purposes, use the viewport.
  if (source.sizing && source.sizing.type === "crop") {
    if (typeof source.sizing.w === "number") w = source.sizing.w;
    if (typeof source.sizing.h === "number") h = source.sizing.h;
  }
  return { x, y, w, h, x2: x + w, y2: y + h };
};

const setElementPosition = (obj, coords) => {
  const ensureTarget = (targetObj) => {
    if (!targetObj || typeof targetObj !== "object") return null;
    return targetObj;
  };
  const targets = [];
  const dataTarget = ensureTarget(obj.data);
  if (dataTarget) targets.push(dataTarget);
  const optionsTarget =
    obj.options && obj.options !== obj.data ? ensureTarget(obj.options) : null;
  if (optionsTarget) targets.push(optionsTarget);
  if (targets.length === 0) {
    obj.data = obj.data && typeof obj.data === "object" ? obj.data : {};
    targets.push(obj.data);
  }
  targets.forEach((target) => {
    if (coords.x !== undefined) target.x = coords.x;
    if (coords.y !== undefined) target.y = coords.y;
  });
};

const dimensionKeyPairs = [
  ["width", "height"],
  ["w", "h"],
  ["cx", "cy"],
  ["slideWidth", "slideHeight"],
  ["slideWidthInches", "slideHeightInches"],
  ["widthInches", "heightInches"],
];

const toNumber = (value) => {
  if (typeof value === "number" && Number.isFinite(value)) return value;
  if (typeof value === "string") {
    const parsed = parseFloat(value);
    return Number.isFinite(parsed) ? parsed : null;
  }
  return null;
};

const readDimensionsFromObject = (candidate, seen = new Set()) => {
  if (!candidate || typeof candidate !== "object") return null;
  if (seen.has(candidate)) return null;
  seen.add(candidate);
  for (const [wKey, hKey] of dimensionKeyPairs) {
    const width = toNumber(candidate[wKey]);
    const height = toNumber(candidate[hKey]);
    if (width !== null && height !== null && width > 0 && height > 0) {
      return { width, height };
    }
  }
  const nestedKeys = ["size", "slideSize", "layout", "slideLayout"];
  for (const key of nestedKeys) {
    const nested = readDimensionsFromObject(candidate[key], seen);
    if (nested) return nested;
  }
  return null;
};

const getSlideDimensions = (slide, pptx) => {
  const candidates = [
    slide?._presLayout,
    slide?._slideLayout,
    slide?._pres?.layout,
    slide?._parent?.layout,
    slide?._layout,
    pptx?._presLayout,
    pptx?._layout,
    pptx?.layout,
    pptx?.presLayout,
  ];
  for (const candidate of candidates) {
    const dims = readDimensionsFromObject(candidate);
    if (dims) {
      // Some internals are in EMUs; convert if values look too large for inches
      const EMU_PER_IN = 914400;
      const looksEmu = dims.width > 1000 || dims.height > 1000;
      if (looksEmu) {
        return {
          width: dims.width / EMU_PER_IN,
          height: dims.height / EMU_PER_IN,
          source: "emu_converted",
        };
      }
      return { ...dims, source: "detected" };
    }
  }
  throw new Error(
    "getSlideDimensions(): Unable to determine slide dimensions from pptxgenjs internals."
  );
};

function alignSlideElements(slide, indices, alignment) {
  if (!slide || !Array.isArray(slide._slideObjects)) {
    throw new Error("Invalid slide object passed to alignSlideElements()");
  }
  if (!Array.isArray(indices) || indices.length === 0) {
    throw new Error("indices must be a non-empty array.");
  }
  if (!VALID_ALIGNMENTS.has(alignment)) {
    throw new Error(`Unsupported alignment option: ${alignment}`);
  }
  const uniqueIndices = [...new Set(indices)];
  const elements = slide._slideObjects;
  const selected = uniqueIndices.map((idx) => {
    if (typeof idx !== "number" || !Number.isInteger(idx)) {
      throw new Error("Element indices must be integers.");
    }
    if (idx < 0 || idx >= elements.length) {
      throw new Error("Element index out of bounds for alignSlideElements().");
    }
    const obj = elements[idx];
    const bounds = getElementBounds(obj);
    return { index: idx, obj, bounds };
  });
  if (selected.length < 2) return;
  const minX = Math.min(...selected.map((item) => item.bounds.x));
  const maxX2 = Math.max(...selected.map((item) => item.bounds.x2));
  const minY = Math.min(...selected.map((item) => item.bounds.y));
  const maxY2 = Math.max(...selected.map((item) => item.bounds.y2));
  const centerX = (minX + maxX2) / 2;
  const centerY = (minY + maxY2) / 2;
  selected.forEach(({ obj, bounds }) => {
    const { w, h } = bounds;
    switch (alignment) {
      case "left":
        setElementPosition(obj, { x: minX });
        break;
      case "right":
        setElementPosition(obj, { x: maxX2 - w });
        break;
      case "top":
        setElementPosition(obj, { y: minY });
        break;
      case "bottom":
        setElementPosition(obj, { y: maxY2 - h });
        break;
      case "horizontallyCenter":
        setElementPosition(obj, { x: centerX - w / 2 });
        break;
      case "verticallyCenter":
        setElementPosition(obj, { y: centerY - h / 2 });
        break;
      default:
        throw new Error(`Unhandled alignment option: ${alignment}`);
    }
  });
}

function distributeSlideElements(slide, indices, direction) {
  if (!slide || !Array.isArray(slide._slideObjects)) {
    throw new Error("Invalid slide object passed to distributeSlideElements()");
  }
  if (!Array.isArray(indices) || indices.length === 0) {
    throw new Error("indices must be a non-empty array.");
  }
  if (direction !== "horizontal" && direction !== "vertical") {
    throw new Error(`Unsupported distribution direction: ${direction}`);
  }
  const uniqueIndices = [...new Set(indices)];
  if (uniqueIndices.length < 2) return;
  const elements = slide._slideObjects;
  const selected = uniqueIndices.map((idx) => {
    if (typeof idx !== "number" || !Number.isInteger(idx)) {
      throw new Error("Element indices must be integers.");
    }
    if (idx < 0 || idx >= elements.length) {
      throw new Error(
        "Element index out of bounds for distributeSlideElements()."
      );
    }
    const obj = elements[idx];
    const bounds = getElementBounds(obj);
    return { index: idx, obj, bounds };
  });
  const axisStartKey = direction === "horizontal" ? "x" : "y";
  const axisEndKey = direction === "horizontal" ? "x2" : "y2";
  const sizeKey = direction === "horizontal" ? "w" : "h";
  selected.sort((a, b) => {
    const delta = a.bounds[axisStartKey] - b.bounds[axisStartKey];
    return Math.abs(delta) > 1e-6 ? delta : a.index - b.index;
  });
  const minCoord = Math.min(
    ...selected.map((item) => item.bounds[axisStartKey])
  );
  const maxCoord = Math.max(...selected.map((item) => item.bounds[axisEndKey]));
  const totalSpan = maxCoord - minCoord;
  const gaps = selected.length - 1;
  const totalSize = selected.reduce(
    (sum, item) => sum + item.bounds[sizeKey],
    0
  );
  const gapSize = gaps > 0 ? (totalSpan - totalSize) / gaps : 0;
  let cursor = minCoord;
  selected.forEach(({ obj, bounds }) => {
    if (direction === "horizontal") {
      setElementPosition(obj, { x: cursor });
      cursor += bounds.w + gapSize;
    } else {
      setElementPosition(obj, { y: cursor });
      cursor += bounds.h + gapSize;
    }
  });
}

function warnIfSlideElementsOutOfBounds(slide, pptx) {
  if (!slide || !Array.isArray(slide._slideObjects)) {
    console.warn(
      "Invalid slide object passed to warnIfSlideElementsOutOfBounds()"
    );
    return;
  }
  const {
    width: slideWidth,
    height: slideHeight,
    source,
  } = getSlideDimensions(slide, pptx);
  const slideIndex =
    pptx && Array.isArray(pptx._slides) ? pptx._slides.indexOf(slide) : -1;
  const slideLabel =
    slideIndex >= 0 ? `Slide ${slideIndex + 1}` : "(Unknown slide index)";
  if (source === "default") {
    console.warn(
      `⚠️ ${slideLabel}: Unable to determine slide dimensions from pptxgenjs internals; assuming width=${slideWidth}, height=${slideHeight}.`
    );
  }
  const EPS = 1e-4;
  let outOfBoundsCount = 0;
  const formatElement = (idx, type, bounds) => {
    const cx = (bounds.x + bounds.w / 2).toFixed(3);
    const cy = (bounds.y + bounds.h / 2).toFixed(3);
    return `Element ${idx} (${type}, center_x=${cx}, center_y=${cy})`;
  };
  slide._slideObjects.forEach((obj, index) => {
    const bounds = getElementBounds(obj);
    const type = inferElementType(obj);
    const violations = [];
    if (bounds.x < -EPS) violations.push(`left=${bounds.x.toFixed(3)} < 0`);
    if (bounds.y < -EPS) violations.push(`top=${bounds.y.toFixed(3)} < 0`);
    if (bounds.x2 > slideWidth + EPS)
      violations.push(
        `right=${bounds.x2.toFixed(3)} > width=${slideWidth.toFixed(3)}`
      );
    if (bounds.y2 > slideHeight + EPS)
      violations.push(
        `bottom=${bounds.y2.toFixed(3)} > height=${slideHeight.toFixed(3)}`
      );
    if (violations.length > 0) {
      outOfBoundsCount++;
      console.warn(
        `⚠️ ${slideLabel}: ${formatElement(
          index,
          type,
          bounds
        )} exceeds slide bounds (${violations.join(", ")}).`
      );
    }
  });
  if (outOfBoundsCount > 0) {
    console.log(
      `⚠️ ${slideLabel}: Found ${outOfBoundsCount} element(s) extending beyond the slide bounds.`
    );
  }
}

module.exports = {
  inferElementType,
  compareElementPosition,
  warnIfSlideHasOverlaps,
  alignSlideElements,
  distributeSlideElements,
  warnIfSlideElementsOutOfBounds,
  getSlideDimensions,
};