@json-to-office/core-pptx 0.1.0

package/dist/index.js

@@ -0,0 +1,1205 @@
+// src/core/generator.ts
+import JSZip from "jszip";
+import { writeFileSync } from "fs";
+
+// src/types.ts
+function isPresentationComponent(component) {
+  return typeof component === "object" && component !== null && component.name === "pptx";
+}
+function isSlideComponent(component) {
+  return typeof component === "object" && component !== null && component.name === "slide";
+}
+
+// src/utils/warn.ts
+var W = {
+  UNKNOWN_COMPONENT: "UNKNOWN_COMPONENT",
+  UNKNOWN_CHART_TYPE: "UNKNOWN_CHART_TYPE",
+  UNKNOWN_SHAPE: "UNKNOWN_SHAPE",
+  CHART_NO_DATA: "CHART_NO_DATA",
+  CHART_INVALID_SERIES: "CHART_INVALID_SERIES",
+  CHART_MULTI_SERIES: "CHART_MULTI_SERIES",
+  IMAGE_NO_SOURCE: "IMAGE_NO_SOURCE",
+  IMAGE_PROBE_FAILED: "IMAGE_PROBE_FAILED",
+  MISSING_TEMPLATE: "MISSING_TEMPLATE",
+  UNKNOWN_PLACEHOLDER: "UNKNOWN_PLACEHOLDER",
+  PLACEHOLDER_NO_POSITION: "PLACEHOLDER_NO_POSITION",
+  THEME_COLOR_FALLBACK: "THEME_COLOR_FALLBACK",
+  UNKNOWN_COLOR: "UNKNOWN_COLOR",
+  GRID_POSITION_CLAMPED: "GRID_POSITION_CLAMPED"
+};
+function warn(warnings, code, message, extra) {
+  if (warnings) {
+    warnings.push({ code, message, ...extra });
+  } else {
+    console.warn(message);
+  }
+}
+
+// src/core/grid.ts
+var DEFAULT_GRID_CONFIG = {
+  columns: 12,
+  rows: 6,
+  margin: { top: 0.5, right: 0.5, bottom: 0.5, left: 0.5 },
+  gutter: { column: 0.2, row: 0.2 }
+};
+function resolveMargin(margin) {
+  if (margin == null) return DEFAULT_GRID_CONFIG.margin;
+  if (typeof margin === "number") return { top: margin, right: margin, bottom: margin, left: margin };
+  return margin;
+}
+function resolveGutter(gutter) {
+  if (gutter == null) return DEFAULT_GRID_CONFIG.gutter;
+  if (typeof gutter === "number") return { column: gutter, row: gutter };
+  return gutter;
+}
+function mergeGridConfigs(base, override) {
+  if (!override) return base;
+  if (!base) return override;
+  const merged = {
+    columns: override.columns ?? base.columns,
+    rows: override.rows ?? base.rows
+  };
+  if (override.margin !== void 0) {
+    if (typeof override.margin === "number") {
+      merged.margin = override.margin;
+    } else {
+      merged.margin = { ...resolveMargin(base.margin), ...override.margin };
+    }
+  } else {
+    merged.margin = base.margin;
+  }
+  if (override.gutter !== void 0) {
+    if (typeof override.gutter === "number") {
+      merged.gutter = override.gutter;
+    } else {
+      merged.gutter = { ...resolveGutter(base.gutter), ...override.gutter };
+    }
+  } else {
+    merged.gutter = base.gutter;
+  }
+  return merged;
+}
+function resolveGridPosition(gridPos, gridConfig, slideWidth, slideHeight, warnings) {
+  const cols = Math.max(1, gridConfig?.columns ?? DEFAULT_GRID_CONFIG.columns);
+  const rows = Math.max(1, gridConfig?.rows ?? DEFAULT_GRID_CONFIG.rows);
+  const margin = resolveMargin(gridConfig?.margin);
+  const gutter = resolveGutter(gridConfig?.gutter);
+  const col = Math.max(0, Math.min(gridPos.column, cols - 1));
+  const row = Math.max(0, Math.min(gridPos.row, rows - 1));
+  const colSpan = Math.max(1, Math.min(gridPos.columnSpan ?? 1, cols - col));
+  const rowSpan = Math.max(1, Math.min(gridPos.rowSpan ?? 1, rows - row));
+  if (gridPos.column !== col || gridPos.row !== row) {
+    warn(
+      warnings,
+      W.GRID_POSITION_CLAMPED,
+      `Grid position clamped: column ${gridPos.column}\u2192${col}, row ${gridPos.row}\u2192${row} (grid: ${cols}\xD7${rows})`
+    );
+  }
+  const availableW = slideWidth - margin.left - margin.right;
+  const availableH = slideHeight - margin.top - margin.bottom;
+  const trackW = (availableW - (cols - 1) * gutter.column) / cols;
+  const trackH = (availableH - (rows - 1) * gutter.row) / rows;
+  const x = margin.left + col * (trackW + gutter.column);
+  const y = margin.top + row * (trackH + gutter.row);
+  const w = colSpan * trackW + (colSpan - 1) * gutter.column;
+  const h = rowSpan * trackH + (rowSpan - 1) * gutter.row;
+  return { x, y, w, h };
+}
+function resolveComponentGridPosition(component, gridConfig, slideWidth, slideHeight, warnings) {
+  const gridPos = component.props.grid;
+  if (!gridPos) return component;
+  const resolved = resolveGridPosition(gridPos, gridConfig, slideWidth, slideHeight, warnings);
+  const { grid: _grid, ...restProps } = component.props;
+  const newProps = { ...restProps };
+  const hasPercentX = typeof newProps.x === "string" || typeof newProps.w === "string";
+  const hasPercentY = typeof newProps.y === "string" || typeof newProps.h === "string";
+  const toPercX = (v) => `${+(v / slideWidth * 100).toFixed(2)}%`;
+  const toPercY = (v) => `${+(v / slideHeight * 100).toFixed(2)}%`;
+  if (newProps.x == null) newProps.x = hasPercentX ? toPercX(resolved.x) : resolved.x;
+  if (newProps.y == null) newProps.y = hasPercentY ? toPercY(resolved.y) : resolved.y;
+  if (newProps.w == null) newProps.w = hasPercentX ? toPercX(resolved.w) : resolved.w;
+  if (newProps.h == null) newProps.h = hasPercentY ? toPercY(resolved.h) : resolved.h;
+  return { ...component, props: newProps };
+}
+
+// src/themes/defaults.ts
+var DEFAULT_STYLES = {
+  title: { fontSize: 36, bold: true, fontColor: "text", align: "center" },
+  subtitle: { fontSize: 20, italic: true, fontColor: "text2", align: "center" },
+  heading1: { fontSize: 28, bold: true, fontColor: "primary" },
+  heading2: { fontSize: 22, bold: true, fontColor: "primary" },
+  heading3: { fontSize: 18, bold: true, fontColor: "text" },
+  body: { fontSize: 14 },
+  caption: { fontSize: 10, italic: true, fontColor: "text2" }
+};
+var DEFAULT_PPTX_THEME = {
+  name: "default",
+  colors: {
+    primary: "#4472C4",
+    secondary: "#ED7D31",
+    accent: "#70AD47",
+    background: "#FFFFFF",
+    text: "#333333",
+    text2: "#44546A",
+    background2: "#E7E6E6",
+    accent4: "#FFC000",
+    accent5: "#5B9BD5",
+    accent6: "#70AD47"
+  },
+  fonts: {
+    heading: "Arial",
+    body: "Arial"
+  },
+  defaults: {
+    fontSize: 18,
+    fontColor: "#333333"
+  },
+  styles: DEFAULT_STYLES
+};
+var PPTX_THEMES = {
+  default: DEFAULT_PPTX_THEME,
+  dark: {
+    name: "dark",
+    colors: {
+      primary: "#5B9BD5",
+      secondary: "#FF6F61",
+      accent: "#6BCB77",
+      background: "#2D2D2D",
+      text: "#FFFFFF",
+      text2: "#CCCCCC",
+      background2: "#3D3D3D",
+      accent4: "#FFB347",
+      accent5: "#77DD77",
+      accent6: "#AEC6CF"
+    },
+    fonts: {
+      heading: "Arial",
+      body: "Arial"
+    },
+    defaults: {
+      fontSize: 18,
+      fontColor: "#FFFFFF"
+    },
+    styles: DEFAULT_STYLES
+  },
+  minimal: {
+    name: "minimal",
+    colors: {
+      primary: "#000000",
+      secondary: "#666666",
+      accent: "#999999",
+      background: "#FFFFFF",
+      text: "#000000",
+      text2: "#444444",
+      background2: "#F5F5F5",
+      accent4: "#BBBBBB",
+      accent5: "#DDDDDD",
+      accent6: "#888888"
+    },
+    fonts: {
+      heading: "Helvetica",
+      body: "Helvetica"
+    },
+    defaults: {
+      fontSize: 18,
+      fontColor: "#000000"
+    },
+    styles: DEFAULT_STYLES
+  }
+};
+function getPptxTheme(name) {
+  return PPTX_THEMES[name] || DEFAULT_PPTX_THEME;
+}
+var pptxThemes = PPTX_THEMES;
+
+// src/core/structure.ts
+function processPresentation(document, options) {
+  const { props, children = [] } = document;
+  const themeName = props.theme ?? "default";
+  const theme = options?.customThemes?.[themeName] ?? getPptxTheme(themeName);
+  const slideWidth = props.slideWidth ?? 10;
+  const slideHeight = props.slideHeight ?? 7.5;
+  let templates;
+  if (props.templates && props.templates.length > 0) {
+    templates = props.templates.map((m) => {
+      const effectiveGrid = mergeGridConfigs(props.grid, m.grid);
+      const resolvedPhs = m.placeholders?.map((ph) => {
+        if (!ph.grid) return ph;
+        const abs = resolveGridPosition(ph.grid, effectiveGrid, slideWidth, slideHeight);
+        return {
+          ...ph,
+          x: ph.x ?? abs.x,
+          y: ph.y ?? abs.y,
+          w: ph.w ?? abs.w,
+          h: ph.h ?? abs.h,
+          grid: void 0
+        };
+      });
+      const resolvedObjects = m.objects?.map(
+        (obj) => resolveComponentGridPosition(obj, effectiveGrid, slideWidth, slideHeight)
+      );
+      return { ...m, placeholders: resolvedPhs, objects: resolvedObjects };
+    });
+  }
+  const slides = [];
+  for (const child of children) {
+    if (isSlideComponent(child)) {
+      const slideComponents = [];
+      if (child.children) {
+        for (const slideChild of child.children) {
+          slideComponents.push(slideChild);
+        }
+      }
+      slides.push({
+        components: slideComponents,
+        background: child.props.background,
+        notes: child.props.notes,
+        layout: child.props.layout,
+        hidden: child.props.hidden,
+        template: child.props.template,
+        placeholders: child.props.placeholders
+      });
+    }
+  }
+  return {
+    metadata: {
+      title: props.title,
+      author: props.author,
+      subject: props.subject,
+      company: props.company
+    },
+    theme,
+    grid: props.grid,
+    slideWidth,
+    slideHeight,
+    rtlMode: props.rtlMode ?? false,
+    pageNumberFormat: props.pageNumberFormat ?? "9",
+    slides,
+    templates
+  };
+}
+
+// src/core/render.ts
+import PptxGenJS from "pptxgenjs";
+
+// src/utils/color.ts
+import { SEMANTIC_COLOR_NAMES } from "@json-to-office/shared-pptx";
+var SEMANTIC_TO_THEME_KEY = {
+  ...Object.fromEntries(SEMANTIC_COLOR_NAMES.map((n) => [n, n])),
+  // Aliases (PowerPoint XML compat)
+  accent1: "primary",
+  accent2: "secondary",
+  accent3: "accent",
+  tx1: "text",
+  tx2: "text2",
+  bg1: "background",
+  bg2: "background2"
+};
+function resolveColor(color, theme, warnings) {
+  const themeKey = SEMANTIC_TO_THEME_KEY[color];
+  if (themeKey) {
+    const resolved = theme.colors[themeKey];
+    if (resolved) return resolved.startsWith("#") ? resolved.slice(1) : resolved;
+    warn(warnings, W.THEME_COLOR_FALLBACK, `Theme color "${themeKey}" not defined, falling back to primary`);
+    return theme.colors.primary.startsWith("#") ? theme.colors.primary.slice(1) : theme.colors.primary;
+  }
+  const bare = color.startsWith("#") ? color.slice(1) : color;
+  if (/^[0-9A-Fa-f]{3}$/.test(bare)) {
+    return bare[0] + bare[0] + bare[1] + bare[1] + bare[2] + bare[2];
+  }
+  if (!/^[0-9A-Fa-f]{6}$/.test(bare)) {
+    warn(warnings, W.UNKNOWN_COLOR, `Unknown color value: "${color}", treating as literal`);
+  }
+  return bare;
+}
+
+// src/components/text.ts
+function resolvePagePlaceholders(text, ctx) {
+  const { slideNumber, totalSlides, pageNumberFormat } = ctx;
+  const fmt = (n) => pageNumberFormat === "09" ? String(n).padStart(String(totalSlides).length, "0") : String(n);
+  return text.replace(/\{PAGE_NUMBER\}/g, fmt(slideNumber)).replace(/\{PAGE_COUNT\}/g, fmt(totalSlides));
+}
+function renderTextComponent(slide, props, theme, warnings, slideCtx) {
+  const style = props.style ? theme.styles?.[props.style] : void 0;
+  const isHeadingStyle = props.style && /^(title|heading)/.test(props.style);
+  const opts = {};
+  if (props.x !== void 0) opts.x = props.x;
+  if (props.y !== void 0) opts.y = props.y;
+  if (props.w !== void 0) opts.w = props.w;
+  if (props.h !== void 0) opts.h = props.h;
+  if (props.h === void 0) {
+    const fontSize = props.fontSize ?? theme.defaults.fontSize ?? 18;
+    const lines = (props.text.match(/\n/g)?.length ?? 0) + 1;
+    opts.h = Math.max(0.5, fontSize / 72 * 1.6 * lines);
+    opts.isTextBox = true;
+  }
+  opts.fontSize = props.fontSize ?? style?.fontSize ?? theme.defaults.fontSize;
+  opts.fontFace = props.fontFace ?? style?.fontFace ?? (isHeadingStyle ? theme.fonts.heading : theme.fonts.body);
+  opts.color = resolveColor(props.color ?? style?.fontColor ?? theme.defaults.fontColor, theme, warnings);
+  const bold = props.bold ?? style?.bold;
+  const italic = props.italic ?? style?.italic;
+  if (bold != null) opts.bold = bold;
+  if (italic != null) opts.italic = italic;
+  if (props.strike) opts.strike = true;
+  if (props.underline !== void 0) {
+    if (typeof props.underline === "boolean") {
+      opts.underline = { style: "sng" };
+    } else {
+      opts.underline = props.underline;
+    }
+  }
+  const align = props.align ?? style?.align;
+  if (align) opts.align = align;
+  opts.valign = props.valign ?? "top";
+  if (props.bullet !== void 0) opts.bullet = props.bullet;
+  opts.margin = props.margin ?? 0;
+  if (props.rotate !== void 0) opts.rotate = props.rotate;
+  if (props.shadow) {
+    opts.shadow = {
+      type: props.shadow.type ?? "outer",
+      color: resolveColor(props.shadow.color ?? "000000", theme, warnings),
+      blur: props.shadow.blur ?? 3,
+      offset: props.shadow.offset ?? 3,
+      angle: props.shadow.angle ?? 45,
+      opacity: props.shadow.opacity ?? 0.5
+    };
+  }
+  if (props.fill) {
+    opts.fill = { color: resolveColor(props.fill.color, theme, warnings) };
+    if (props.fill.transparency !== void 0) {
+      opts.fill.transparency = props.fill.transparency;
+    }
+  }
+  if (props.hyperlink) {
+    if (props.hyperlink.url) {
+      opts.hyperlink = {
+        url: props.hyperlink.url,
+        tooltip: props.hyperlink.tooltip
+      };
+    } else if (props.hyperlink.slide) {
+      opts.hyperlink = {
+        slide: props.hyperlink.slide,
+        tooltip: props.hyperlink.tooltip
+      };
+    }
+  }
+  const lineSpacing = props.lineSpacing ?? style?.lineSpacing;
+  if (lineSpacing !== void 0) opts.lineSpacing = lineSpacing;
+  const charSpacing = props.charSpacing ?? style?.charSpacing;
+  if (charSpacing !== void 0) opts.charSpacing = charSpacing;
+  if (props.paraSpaceBefore !== void 0) opts.paraSpaceBefore = props.paraSpaceBefore;
+  const paraSpaceAfter = props.paraSpaceAfter ?? style?.paraSpaceAfter;
+  if (paraSpaceAfter !== void 0) opts.paraSpaceAfter = paraSpaceAfter;
+  if (props.breakLine) opts.breakLine = true;
+  const text = slideCtx ? resolvePagePlaceholders(props.text, slideCtx) : props.text;
+  slide.addText(text, opts);
+}
+
+// src/components/image.ts
+import path from "path";
+import probe from "probe-image-size";
+function isPrivateUrl(urlStr) {
+  try {
+    const { hostname } = new URL(urlStr);
+    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]" || hostname.startsWith("10.") || hostname.startsWith("192.168.") || hostname.startsWith("169.254.") || hostname.endsWith(".local") || hostname.endsWith(".internal")) return true;
+    if (hostname.startsWith("172.")) {
+      const second = parseInt(hostname.split(".")[1], 10);
+      if (second >= 16 && second <= 31) return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function probeImageSize(imagePath, warnings) {
+  try {
+    if (/^data:image\//.test(imagePath)) {
+      const base64Data = imagePath.split(",")[1];
+      if (!base64Data) return void 0;
+      const buf = Buffer.from(base64Data, "base64");
+      const result2 = probe.sync(buf);
+      return result2 ? { width: result2.width, height: result2.height } : void 0;
+    }
+    if (/^https?:\/\//.test(imagePath)) {
+      if (isPrivateUrl(imagePath)) return void 0;
+      const result2 = await probe(imagePath, { timeout: 5e3 });
+      return { width: result2.width, height: result2.height };
+    }
+    const resolved = path.resolve(imagePath);
+    if (!resolved.startsWith(process.cwd())) return void 0;
+    const { createReadStream } = await import("fs");
+    const result = await probe(createReadStream(resolved));
+    return result ? { width: result.width, height: result.height } : void 0;
+  } catch (err) {
+    warn(warnings, W.IMAGE_PROBE_FAILED, `Image probe failed: ${err instanceof Error ? err.message : String(err)}`, { component: "image" });
+    return void 0;
+  }
+}
+async function renderImageComponent(slide, props, theme, warnings) {
+  const opts = {};
+  if (props.path) {
+    opts.path = props.path;
+  } else if (props.base64) {
+    opts.data = props.base64;
+  } else {
+    warn(warnings, W.IMAGE_NO_SOURCE, "Image component missing both path and base64", { component: "image" });
+    return;
+  }
+  if (props.x !== void 0) opts.x = props.x;
+  if (props.y !== void 0) opts.y = props.y;
+  if (props.w !== void 0) opts.w = props.w;
+  if (props.h !== void 0) opts.h = props.h;
+  if (props.sizing && (props.sizing.type === "contain" || props.sizing.type === "cover")) {
+    const source = props.path || props.base64;
+    const intrinsic = source ? await probeImageSize(source, warnings) : void 0;
+    const boxW = Number(props.sizing.w ?? props.w);
+    const boxH = Number(props.sizing.h ?? props.h);
+    if (intrinsic && !isNaN(boxW) && !isNaN(boxH)) {
+      const imgAspect = intrinsic.width / intrinsic.height;
+      if (props.sizing.type === "contain") {
+        const boxAspect = boxW / boxH;
+        let fitW, fitH;
+        if (imgAspect > boxAspect) {
+          fitW = boxW;
+          fitH = boxW / imgAspect;
+        } else {
+          fitH = boxH;
+          fitW = boxH * imgAspect;
+        }
+        const baseX = Number(props.x ?? 0);
+        const baseY = Number(props.y ?? 0);
+        opts.x = baseX + (boxW - fitW) / 2;
+        opts.y = baseY + (boxH - fitH) / 2;
+        opts.w = fitW;
+        opts.h = fitH;
+      } else {
+        opts.w = intrinsic.width;
+        opts.h = intrinsic.height;
+        opts.sizing = { type: "cover", w: boxW, h: boxH };
+      }
+    } else {
+      opts.sizing = { ...props.sizing, w: boxW, h: boxH };
+    }
+  } else if (props.sizing) {
+    opts.sizing = {
+      ...props.sizing,
+      w: props.sizing.w ?? props.w,
+      h: props.sizing.h ?? props.h
+    };
+  }
+  if (props.rotate !== void 0) opts.rotate = props.rotate;
+  if (props.rounding) opts.rounding = true;
+  if (props.shadow) {
+    opts.shadow = {
+      type: props.shadow.type ?? "outer",
+      color: resolveColor(props.shadow.color ?? "000000", theme, warnings),
+      blur: props.shadow.blur ?? 3,
+      offset: props.shadow.offset ?? 3,
+      angle: props.shadow.angle ?? 45,
+      opacity: props.shadow.opacity ?? 0.5
+    };
+  }
+  if (props.hyperlink) {
+    if (props.hyperlink.url) {
+      opts.hyperlink = {
+        url: props.hyperlink.url,
+        tooltip: props.hyperlink.tooltip
+      };
+    } else if (props.hyperlink.slide) {
+      opts.hyperlink = {
+        slide: props.hyperlink.slide,
+        tooltip: props.hyperlink.tooltip
+      };
+    }
+  }
+  if (props.alt) opts.altText = props.alt;
+  slide.addImage(opts);
+}
+
+// src/components/shape.ts
+var SHAPE_TYPE_MAP = {
+  rect: "rect",
+  roundRect: "roundRect",
+  ellipse: "ellipse",
+  triangle: "triangle",
+  diamond: "diamond",
+  pentagon: "pentagon",
+  hexagon: "hexagon",
+  star5: "star5",
+  star6: "star6",
+  line: "line",
+  arrow: "rightArrow",
+  chevron: "chevron",
+  cloud: "cloud",
+  heart: "heart",
+  lightning: "lightningBolt"
+};
+function buildShapeOpts(props, theme, warnings) {
+  const opts = {};
+  if (props.x !== void 0) opts.x = props.x;
+  if (props.y !== void 0) opts.y = props.y;
+  if (props.w !== void 0) opts.w = props.w;
+  if (props.h !== void 0) opts.h = props.h;
+  if (props.fill) {
+    opts.fill = { color: resolveColor(props.fill.color, theme, warnings) };
+    if (props.fill.transparency !== void 0) {
+      opts.fill.transparency = props.fill.transparency;
+    }
+  }
+  if (props.line) {
+    opts.line = {};
+    if (props.line.color) opts.line.color = resolveColor(props.line.color, theme, warnings);
+    if (props.line.width) opts.line.width = props.line.width;
+    if (props.line.dashType) opts.line.dashType = props.line.dashType;
+  }
+  if (props.rotate !== void 0) opts.rotate = props.rotate;
+  if (props.rectRadius !== void 0) opts.rectRadius = props.rectRadius;
+  if (props.shadow) {
+    opts.shadow = {
+      type: props.shadow.type ?? "outer",
+      color: resolveColor(props.shadow.color ?? "000000", theme, warnings),
+      blur: props.shadow.blur ?? 3,
+      offset: props.shadow.offset ?? 3,
+      angle: props.shadow.angle ?? 45,
+      opacity: props.shadow.opacity ?? 0.5
+    };
+  }
+  return opts;
+}
+function renderShapeComponent(slide, props, theme, pptx, warnings) {
+  const shapeTypeName = SHAPE_TYPE_MAP[props.type] || props.type;
+  const shapeType = pptx.ShapeType[shapeTypeName];
+  if (!shapeType) {
+    warn(warnings, W.UNKNOWN_SHAPE, `Unknown shape type: ${props.type}`, { component: "shape" });
+    return;
+  }
+  const style = props.style ? theme.styles?.[props.style] : void 0;
+  const isHeadingStyle = props.style && /^(title|heading)/.test(props.style);
+  const opts = buildShapeOpts(props, theme, warnings);
+  if (props.text && (!Array.isArray(props.text) || props.text.length > 0)) {
+    opts.shape = shapeType;
+    opts.fontSize = props.fontSize ?? style?.fontSize ?? theme.defaults.fontSize;
+    opts.fontFace = props.fontFace ?? style?.fontFace ?? (isHeadingStyle ? theme.fonts.heading : theme.fonts.body);
+    opts.color = resolveColor(props.fontColor ?? style?.fontColor ?? theme.defaults.fontColor, theme, warnings);
+    const bold = props.bold ?? style?.bold;
+    const italic = props.italic ?? style?.italic;
+    if (bold != null) opts.bold = bold;
+    if (italic != null) opts.italic = italic;
+    const charSpacing = props.charSpacing ?? style?.charSpacing;
+    if (charSpacing !== void 0) opts.charSpacing = charSpacing;
+    const align = props.align ?? style?.align;
+    if (align) opts.align = align;
+    opts.valign = props.valign ?? "top";
+    if (Array.isArray(props.text)) {
+      const textSegments = props.text.map((seg) => {
+        const segOpts = {};
+        if (seg.fontSize != null) segOpts.fontSize = seg.fontSize;
+        if (seg.fontFace != null) segOpts.fontFace = seg.fontFace;
+        if (seg.color != null) segOpts.color = resolveColor(seg.color, theme, warnings);
+        if (seg.bold != null) segOpts.bold = seg.bold;
+        if (seg.italic != null) segOpts.italic = seg.italic;
+        if (seg.breakLine != null) segOpts.breakLine = seg.breakLine;
+        if (seg.charSpacing != null) segOpts.charSpacing = seg.charSpacing;
+        if (seg.spaceBefore != null) segOpts.paraSpaceBefore = seg.spaceBefore;
+        if (seg.spaceAfter != null) segOpts.paraSpaceAfter = seg.spaceAfter;
+        return { text: seg.text, options: segOpts };
+      });
+      slide.addText(textSegments, opts);
+    } else {
+      slide.addText(props.text, opts);
+    }
+  } else {
+    slide.addShape(shapeType, opts);
+  }
+}
+
+// src/components/table.ts
+var EMOJI_PRONE_CHARS = /[✓✔✗✘☐☑☒★☆●○■□▶◀▲▼⚡⚠❌❓❗]/gu;
+function applyTextVariationSelector(text) {
+  return text.replace(EMOJI_PRONE_CHARS, (ch) => ch + "\uFE0E");
+}
+function renderTableComponent(slide, props, theme, pptx, warnings) {
+  let bgFill;
+  let headerFill;
+  let borderRadiusTableW;
+  if (props.borderRadius && pptx && props.rows.length >= 2) {
+    const lastRow = props.rows[props.rows.length - 1];
+    const lastCell = lastRow?.[0];
+    bgFill = props.fill ? resolveColor(props.fill, theme, warnings) : typeof lastCell === "object" && lastCell.fill ? resolveColor(lastCell.fill, theme, warnings) : "FFFFFF";
+    const firstCell = props.rows[0]?.[0];
+    headerFill = typeof firstCell === "object" && firstCell.fill ? resolveColor(firstCell.fill, theme, warnings) : bgFill;
+    borderRadiusTableW = Array.isArray(props.colW) ? props.colW.reduce((sum, w) => sum + w, 0) : typeof props.colW === "number" ? props.colW * (props.rows[0]?.length ?? 1) : typeof props.w === "number" ? props.w : 5;
+  }
+  const innerBorder = props.border ? {
+    type: props.border.type ?? "solid",
+    pt: props.border.pt ?? 1,
+    color: resolveColor(props.border.color ?? "000000", theme, warnings)
+  } : void 0;
+  const buildBorderRadiusBorders = (rowIndex, colIndex, colCount) => {
+    const isTop = rowIndex === 0;
+    const isBottom = rowIndex === props.rows.length - 1;
+    const isLeft = colIndex === 0;
+    const isRight = colIndex === colCount - 1;
+    const zeroBorder = { type: "none", pt: 0 };
+    const hInner = innerBorder ?? zeroBorder;
+    return [
+      isTop || rowIndex === 1 ? zeroBorder : hInner,
+      // top: outer + header-body seam
+      isRight ? zeroBorder : hInner,
+      // right
+      isBottom || rowIndex === 0 ? zeroBorder : hInner,
+      // bottom: outer + header-body seam
+      isLeft ? zeroBorder : hInner
+      // left
+    ];
+  };
+  const lastRowIdx = props.rows.length - 1;
+  const tableRows = props.rows.map(
+    (row, rowIndex) => row.map((cell, colIndex) => {
+      const lastColIdx = row.length - 1;
+      const isCorner = bgFill && (rowIndex === 0 || rowIndex === lastRowIdx) && (colIndex === 0 || colIndex === lastColIdx);
+      if (typeof cell === "string") {
+        if (!bgFill) return { text: applyTextVariationSelector(cell) };
+        const isHeader = rowIndex === 0;
+        const opts2 = {
+          border: buildBorderRadiusBorders(rowIndex, colIndex, row.length)
+        };
+        if (!isCorner) opts2.fill = { color: isHeader ? headerFill : bgFill };
+        return { text: applyTextVariationSelector(cell), options: opts2 };
+      }
+      const cellOpts = {};
+      if (cell.color) cellOpts.color = resolveColor(cell.color, theme, warnings);
+      if (bgFill) {
+        const isHeader = rowIndex === 0;
+        if (!isCorner) {
+          const resolvedFill = cell.fill ? resolveColor(cell.fill, theme, warnings) : isHeader ? headerFill : bgFill;
+          cellOpts.fill = { color: resolvedFill };
+        }
+        cellOpts.border = buildBorderRadiusBorders(rowIndex, colIndex, row.length);
+      } else if (cell.fill) {
+        cellOpts.fill = { color: resolveColor(cell.fill, theme, warnings) };
+      }
+      if (cell.fontSize) cellOpts.fontSize = cell.fontSize;
+      if (cell.fontFace) cellOpts.fontFace = cell.fontFace;
+      if (cell.bold) cellOpts.bold = true;
+      if (cell.italic) cellOpts.italic = true;
+      if (cell.align) cellOpts.align = cell.align;
+      if (cell.valign) cellOpts.valign = cell.valign;
+      if (cell.colspan) cellOpts.colspan = cell.colspan;
+      if (cell.rowspan) cellOpts.rowspan = cell.rowspan;
+      if (cell.margin !== void 0) cellOpts.margin = cell.margin;
+      return { text: applyTextVariationSelector(cell.text), options: cellOpts };
+    })
+  );
+  const opts = {};
+  if (props.x !== void 0) opts.x = props.x;
+  if (props.y !== void 0) opts.y = props.y;
+  if (props.w !== void 0) opts.w = props.w;
+  if (props.h !== void 0) opts.h = props.h;
+  if (props.colW !== void 0) opts.colW = props.colW;
+  if (props.rowH !== void 0) opts.rowH = props.rowH;
+  if (props.border && !bgFill) {
+    opts.border = {
+      type: props.border.type ?? "solid",
+      pt: props.border.pt ?? 1,
+      color: resolveColor(props.border.color ?? "000000", theme, warnings)
+    };
+  }
+  if (props.fill) opts.fill = { color: resolveColor(props.fill, theme, warnings) };
+  opts.fontSize = props.fontSize ?? theme.defaults.fontSize;
+  opts.fontFace = props.fontFace ?? theme.fonts.body;
+  if (props.color) opts.color = resolveColor(props.color, theme, warnings);
+  if (props.align) opts.align = props.align;
+  opts.valign = props.valign ?? "middle";
+  if (props.autoPage) opts.autoPage = true;
+  if (props.autoPageRepeatHeader) {
+    opts.autoPageRepeatHeader = true;
+    opts.autoPageHeaderRows = 1;
+  }
+  if (props.margin !== void 0) opts.margin = props.margin;
+  if (props.borderRadius && pptx && typeof props.x === "number" && typeof props.y === "number") {
+    let tableH = props.h ?? 2;
+    if (typeof props.rowH === "number") {
+      tableH = props.rowH * props.rows.length;
+    } else if (Array.isArray(props.rowH)) {
+      tableH = props.rowH.reduce((sum, h) => sum + h, 0);
+    }
+    const headerH = typeof props.rowH === "number" ? props.rowH : Array.isArray(props.rowH) ? props.rowH[0] : 0.45;
+    const tableW = borderRadiusTableW;
+    const noLine = { type: "none" };
+    slide.addShape(pptx.ShapeType.roundRect, {
+      x: props.x,
+      y: props.y,
+      w: tableW,
+      h: headerH,
+      fill: { color: headerFill },
+      rectRadius: props.borderRadius,
+      line: noLine
+    });
+    slide.addShape(pptx.ShapeType.rect, {
+      x: props.x,
+      y: props.y + headerH - props.borderRadius,
+      w: tableW,
+      h: props.borderRadius,
+      fill: { color: headerFill },
+      line: noLine
+    });
+    const bodyY = props.y + headerH;
+    const bodyH = tableH - headerH;
+    slide.addShape(pptx.ShapeType.roundRect, {
+      x: props.x,
+      y: bodyY,
+      w: tableW,
+      h: bodyH,
+      fill: { color: bgFill },
+      rectRadius: props.borderRadius,
+      line: noLine
+    });
+    slide.addShape(pptx.ShapeType.rect, {
+      x: props.x,
+      y: bodyY,
+      w: tableW,
+      h: props.borderRadius,
+      fill: { color: bgFill },
+      line: noLine
+    });
+  }
+  if (bgFill && borderRadiusTableW !== void 0) {
+    opts.w = borderRadiusTableW;
+    opts.border = [{ type: "none" }, { type: "none" }, { type: "none" }, { type: "none" }];
+  }
+  slide.addTable(tableRows, opts);
+}
+
+// src/utils/environment.ts
+function isNodeEnvironment() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null && typeof process.versions.node === "string";
+}
+
+// src/components/highcharts.ts
+var PX_PER_INCH = 96;
+var DEFAULT_EXPORT_SERVER_URL = "http://localhost:7801";
+function getExportServerUrl(propsUrl) {
+  return propsUrl || process.env.HIGHCHARTS_SERVER_URL || DEFAULT_EXPORT_SERVER_URL;
+}
+async function generateChart(config) {
+  if (!isNodeEnvironment()) {
+    throw new Error(
+      "Highcharts export server requires a Node.js environment. Chart generation is not available in browser environments."
+    );
+  }
+  const serverUrl = getExportServerUrl(config.serverUrl);
+  const response = await fetch(`${serverUrl}/export`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      infile: config.options,
+      type: "png",
+      b64: true,
+      scale: config.scale
+    })
+  }).catch((error) => {
+    throw new Error(
+      `Highcharts Export Server is not running at ${serverUrl}. Start it with: npx highcharts-export-server --enableServer true
+Cause: ${error instanceof Error ? error.message : String(error)}`
+    );
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Highcharts export server returned ${response.status}: ${response.statusText}`
+    );
+  }
+  const base64Data = await response.text();
+  return {
+    base64DataUri: `data:image/png;base64,${base64Data}`,
+    width: config.options.chart?.width ?? 960,
+    height: config.options.chart?.height ?? 720
+  };
+}
+async function renderHighchartsComponent(slide, props, _theme, _warnings) {
+  const chart = await generateChart(props);
+  const w = props.w ?? chart.width / PX_PER_INCH;
+  const h = props.h ?? chart.height / PX_PER_INCH;
+  slide.addImage({
+    data: chart.base64DataUri,
+    x: props.x ?? 0,
+    y: props.y ?? 0,
+    w,
+    h
+  });
+}
+
+// src/components/chart.ts
+var CHART_TYPE_MAP = {
+  area: "area",
+  bar: "bar",
+  bar3D: "bar3D",
+  bubble: "bubble",
+  doughnut: "doughnut",
+  line: "line",
+  pie: "pie",
+  radar: "radar",
+  scatter: "scatter"
+};
+var DEFAULT_THEME_COLORS = ["primary", "secondary", "accent", "accent4", "accent5", "accent6"];
+function renderChartComponent(slide, props, theme, _pptx, warnings) {
+  const chartType = CHART_TYPE_MAP[props.type];
+  if (!chartType) {
+    warn(warnings, W.UNKNOWN_CHART_TYPE, `Unknown chart type: ${props.type}`, { component: "chart" });
+    return;
+  }
+  if (!props.data || props.data.length === 0) {
+    warn(warnings, W.CHART_NO_DATA, "Chart component has no data series", { component: "chart" });
+    return;
+  }
+  for (const series of props.data) {
+    if (!series.labels || !series.values) {
+      warn(warnings, W.CHART_INVALID_SERIES, `Chart series "${series.name ?? "(unnamed)"}" missing labels or values`, { component: "chart" });
+      return;
+    }
+  }
+  if ((chartType === "pie" || chartType === "doughnut") && props.data.length > 1) {
+    warn(warnings, W.CHART_MULTI_SERIES, `${props.type} chart has ${props.data.length} series \u2014 only the first will render`, { component: "chart" });
+  }
+  const data = props.data.map((series) => {
+    const d = {};
+    if (series.name !== void 0) d.name = series.name;
+    if (series.labels) d.labels = series.labels;
+    if (series.values) d.values = series.values;
+    if (series.sizes) d.sizes = series.sizes;
+    return d;
+  });
+  const opts = {};
+  if (props.x !== void 0) opts.x = props.x;
+  if (props.y !== void 0) opts.y = props.y;
+  if (props.w !== void 0) opts.w = props.w;
+  if (props.h !== void 0) opts.h = props.h;
+  const colorSources = props.chartColors ?? DEFAULT_THEME_COLORS;
+  opts.chartColors = colorSources.map((c) => resolveColor(c, theme, warnings));
+  const themeTextColor = resolveColor("text", theme, warnings);
+  opts.titleColor = props.titleColor ? resolveColor(props.titleColor, theme, warnings) : themeTextColor;
+  opts.legendColor = props.legendColor ? resolveColor(props.legendColor, theme, warnings) : themeTextColor;
+  opts.catAxisLabelColor = props.catAxisLabelColor ? resolveColor(props.catAxisLabelColor, theme, warnings) : themeTextColor;
+  opts.valAxisLabelColor = props.valAxisLabelColor ? resolveColor(props.valAxisLabelColor, theme, warnings) : themeTextColor;
+  if (props.showLegend !== void 0) opts.showLegend = props.showLegend;
+  if (props.showTitle !== void 0) opts.showTitle = props.showTitle;
+  if (props.showValue !== void 0) opts.showValue = props.showValue;
+  if (props.showPercent !== void 0) opts.showPercent = props.showPercent;
+  if (props.showLabel !== void 0) opts.showLabel = props.showLabel;
+  if (props.showSerName !== void 0) opts.showSerName = props.showSerName;
+  if (props.title !== void 0) opts.title = props.title;
+  if (props.titleFontSize !== void 0) opts.titleFontSize = props.titleFontSize;
+  if (props.titleFontFace !== void 0) opts.titleFontFace = props.titleFontFace;
+  if (props.legendPos !== void 0) opts.legendPos = props.legendPos;
+  if (props.legendFontSize !== void 0) opts.legendFontSize = props.legendFontSize;
+  if (props.legendFontFace !== void 0) opts.legendFontFace = props.legendFontFace;
+  if (props.catAxisTitle !== void 0) {
+    opts.catAxisTitle = props.catAxisTitle;
+    opts.showCatAxisTitle = true;
+  }
+  if (props.catAxisHidden !== void 0) opts.catAxisHidden = props.catAxisHidden;
+  if (props.catAxisLabelRotate !== void 0) opts.catAxisLabelRotate = props.catAxisLabelRotate;
+  if (props.catAxisLabelFontSize !== void 0) opts.catAxisLabelFontSize = props.catAxisLabelFontSize;
+  if (props.valAxisTitle !== void 0) {
+    opts.valAxisTitle = props.valAxisTitle;
+    opts.showValAxisTitle = true;
+  }
+  if (props.valAxisHidden !== void 0) opts.valAxisHidden = props.valAxisHidden;
+  if (props.valAxisMinVal !== void 0) opts.valAxisMinVal = props.valAxisMinVal;
+  if (props.valAxisMaxVal !== void 0) opts.valAxisMaxVal = props.valAxisMaxVal;
+  if (props.valAxisLabelFormatCode !== void 0) opts.valAxisLabelFormatCode = props.valAxisLabelFormatCode;
+  if (props.valAxisMajorUnit !== void 0) opts.valAxisMajorUnit = props.valAxisMajorUnit;
+  if (props.barDir !== void 0) opts.barDir = props.barDir;
+  if (props.barGrouping !== void 0) opts.barGrouping = props.barGrouping;
+  if (props.barGapWidthPct !== void 0) opts.barGapWidthPct = props.barGapWidthPct;
+  if (props.lineSmooth !== void 0) opts.lineSmooth = props.lineSmooth;
+  if (props.lineDataSymbol !== void 0) opts.lineDataSymbol = props.lineDataSymbol;
+  if (props.lineSize !== void 0) opts.lineSize = props.lineSize;
+  if (props.firstSliceAng !== void 0) opts.firstSliceAng = props.firstSliceAng;
+  if (props.holeSize !== void 0) opts.holeSize = props.holeSize;
+  if (props.radarStyle !== void 0) opts.radarStyle = props.radarStyle;
+  opts.dataLabelColor = props.dataLabelColor ? resolveColor(props.dataLabelColor, theme, warnings) : themeTextColor;
+  if (props.dataLabelFontSize !== void 0) opts.dataLabelFontSize = props.dataLabelFontSize;
+  if (props.dataLabelFontFace !== void 0) opts.dataLabelFontFace = props.dataLabelFontFace;
+  if (props.dataLabelFontBold !== void 0) opts.dataLabelFontBold = props.dataLabelFontBold;
+  if (props.dataLabelPosition !== void 0) opts.dataLabelPosition = props.dataLabelPosition;
+  slide.addChart(chartType, data, opts);
+}
+
+// src/components/index.ts
+async function renderComponent(slide, component, theme, pptx, warnings, slideCtx) {
+  if (component.enabled === false) return;
+  const { name, props } = component;
+  const p = props;
+  switch (name) {
+    case "text":
+      renderTextComponent(slide, p, theme, warnings, slideCtx);
+      break;
+    case "image":
+      await renderImageComponent(slide, p, theme, warnings);
+      break;
+    case "shape":
+      renderShapeComponent(slide, p, theme, pptx, warnings);
+      break;
+    case "table":
+      renderTableComponent(slide, p, theme, pptx, warnings);
+      break;
+    case "highcharts":
+      await renderHighchartsComponent(slide, p, theme, warnings);
+      break;
+    case "chart":
+      renderChartComponent(slide, p, theme, pptx, warnings);
+      break;
+    default:
+      warn(warnings, W.UNKNOWN_COMPONENT, `Unknown PPTX component type: ${name}`, { component: name });
+  }
+}
+
+// src/core/template.ts
+function buildSlideTemplateProps(def, theme, warnings) {
+  const result = { title: def.name };
+  if (def.background) {
+    if (def.background.color) {
+      result.background = { color: resolveColor(def.background.color, theme, warnings) };
+    } else if (def.background.image) {
+      if (def.background.image.path) {
+        result.background = { path: def.background.image.path };
+      } else if (def.background.image.base64) {
+        result.background = { data: def.background.image.base64 };
+      }
+    }
+  }
+  if (def.margin !== void 0) result.margin = def.margin;
+  if (def.slideNumber) {
+    result.slideNumber = {
+      x: def.slideNumber.x,
+      y: def.slideNumber.y
+    };
+    if (def.slideNumber.w !== void 0) result.slideNumber.w = def.slideNumber.w;
+    if (def.slideNumber.h !== void 0) result.slideNumber.h = def.slideNumber.h;
+    if (def.slideNumber.color) result.slideNumber.color = resolveColor(def.slideNumber.color, theme, warnings);
+    if (def.slideNumber.fontSize) result.slideNumber.fontSize = def.slideNumber.fontSize;
+  }
+  return result;
+}
+
+// src/core/render.ts
+async function renderPresentation(processed, warnings) {
+  const pptx = new PptxGenJS();
+  if (processed.metadata.title) pptx.title = processed.metadata.title;
+  if (processed.metadata.author) pptx.author = processed.metadata.author;
+  if (processed.metadata.subject) pptx.subject = processed.metadata.subject;
+  if (processed.metadata.company) pptx.company = processed.metadata.company;
+  pptx.defineLayout({
+    name: "CUSTOM",
+    width: processed.slideWidth,
+    height: processed.slideHeight
+  });
+  pptx.layout = "CUSTOM";
+  if (processed.rtlMode) {
+    pptx.rtlMode = true;
+  }
+  pptx.theme = {
+    headFontFace: processed.theme.fonts.heading,
+    bodyFontFace: processed.theme.fonts.body
+  };
+  const templateMap = new Map(processed.templates?.map((m) => [m.name, m]) ?? []);
+  if (processed.templates) {
+    for (const templateDef of processed.templates) {
+      const templateProps = buildSlideTemplateProps(templateDef, processed.theme, warnings);
+      pptx.defineSlideMaster(templateProps);
+    }
+  }
+  const totalSlides = processed.slides.length;
+  for (let slideIdx = 0; slideIdx < totalSlides; slideIdx++) {
+    const slideData = processed.slides[slideIdx];
+    const slideCtx = {
+      slideNumber: slideIdx + 1,
+      totalSlides,
+      pageNumberFormat: processed.pageNumberFormat
+    };
+    const slide = slideData.template ? pptx.addSlide({ masterName: slideData.template }) : pptx.addSlide();
+    if (slideData.background) {
+      if (slideData.background.color) {
+        slide.background = { color: resolveColor(slideData.background.color, processed.theme, warnings) };
+      } else if (slideData.background.image) {
+        if (slideData.background.image.path) {
+          slide.background = { path: slideData.background.image.path };
+        } else if (slideData.background.image.base64) {
+          slide.background = { data: slideData.background.image.base64 };
+        }
+      }
+    }
+    if (slideData.hidden) {
+      slide.hidden = true;
+    }
+    const templateDef = slideData.template ? templateMap.get(slideData.template) : void 0;
+    if (slideData.template && !templateDef) {
+      warn(warnings, W.MISSING_TEMPLATE, `Unknown template "${slideData.template}". Available: ${[...templateMap.keys()].join(", ")}`, { slide: slideIdx });
+    }
+    const effectiveGrid = mergeGridConfigs(processed.grid, templateDef?.grid);
+    if (templateDef?.objects) {
+      for (const obj of templateDef.objects) {
+        await renderComponent(slide, obj, processed.theme, pptx, warnings, slideCtx);
+      }
+    }
+    for (const component of slideData.components) {
+      const resolved = resolveComponentGridPosition(
+        component,
+        effectiveGrid,
+        processed.slideWidth,
+        processed.slideHeight,
+        warnings
+      );
+      await renderComponent(slide, resolved, processed.theme, pptx, warnings, slideCtx);
+    }
+    if (slideData.placeholders) {
+      if (templateDef) {
+        const phMap = new Map(templateDef.placeholders?.map((p) => [p.name, p]) ?? []);
+        for (const [phName, component] of Object.entries(slideData.placeholders)) {
+          const phDef = phMap.get(phName);
+          if (!phDef) {
+            warn(warnings, W.UNKNOWN_PLACEHOLDER, `Unknown placeholder "${phName}" in template "${slideData.template}". Available: ${[...phMap.keys()].join(", ")}`, { slide: slideIdx });
+            continue;
+          }
+          const gridResolved = resolveComponentGridPosition(
+            component,
+            effectiveGrid,
+            processed.slideWidth,
+            processed.slideHeight,
+            warnings
+          );
+          const posDefaults = {};
+          if (phDef.x != null) posDefaults.x = phDef.x;
+          if (phDef.y != null) posDefaults.y = phDef.y;
+          if (phDef.w != null) posDefaults.w = phDef.w;
+          if (phDef.h != null) posDefaults.h = phDef.h;
+          const props = { ...posDefaults, ...phDef.defaults?.props ?? {}, ...gridResolved.props };
+          await renderComponent(slide, { ...gridResolved, props }, processed.theme, pptx, warnings, slideCtx);
+        }
+      } else {
+        for (const [phName, component] of Object.entries(slideData.placeholders)) {
+          const hasPosition = component.props.x != null || component.props.y != null || component.props.grid;
+          if (hasPosition) {
+            const resolved = resolveComponentGridPosition(
+              component,
+              effectiveGrid,
+              processed.slideWidth,
+              processed.slideHeight,
+              warnings
+            );
+            await renderComponent(slide, resolved, processed.theme, pptx, warnings, slideCtx);
+          } else {
+            warn(warnings, W.PLACEHOLDER_NO_POSITION, `Placeholder "${phName}" has no template and no explicit position \u2014 skipped`, { slide: slideIdx });
+          }
+        }
+      }
+    }
+    if (slideData.notes) {
+      slide.addNotes(slideData.notes);
+    }
+  }
+  return pptx;
+}
+
+// src/core/generator.ts
+function isPresentationComponentDefinition(definition) {
+  if (typeof definition !== "object" || definition === null) return false;
+  const def = definition;
+  return def.name === "pptx" && "props" in def;
+}
+async function generatePresentation(document, options, warnings) {
+  if (!document || document.name !== "pptx") {
+    throw new Error("Top-level component must be a pptx component");
+  }
+  const processed = processPresentation(document, options);
+  return await renderPresentation(processed, warnings);
+}
+async function generateBufferFromJson(jsonConfig, options) {
+  const result = await generateBufferWithWarnings(jsonConfig, options);
+  return result.buffer;
+}
+async function generateBufferWithWarnings(jsonConfig, options) {
+  let component;
+  if (typeof jsonConfig === "string") {
+    const parsed = JSON.parse(jsonConfig);
+    if (!isPresentationComponent(parsed)) {
+      throw new Error("Parsed JSON must be a presentation component");
+    }
+    component = parsed;
+  } else {
+    component = jsonConfig;
+  }
+  const warnings = [];
+  const pptx = await generatePresentation(component, options, warnings);
+  const data = await pptx.write({ outputType: "nodebuffer" });
+  const buffer = await neutralizeTableStyle(data);
+  return { buffer, warnings };
+}
+async function generateAndSaveFromJson(jsonConfig, outputPath, options) {
+  const buffer = await generateBufferFromJson(jsonConfig, options);
+  writeFileSync(outputPath, buffer);
+}
+async function generateFromFile(filePath, outputPath) {
+  const { readFileSync } = await import("fs");
+  const json = readFileSync(filePath, "utf-8");
+  await generateAndSaveFromJson(json, outputPath);
+}
+var MEDIUM_STYLE_2_ACCENT_1 = "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}";
+var NO_STYLE_NO_GRID = "{2D5ABB26-0587-4C30-8999-92F81FD0307C}";
+async function neutralizeTableStyle(buffer) {
+  const zip = await JSZip.loadAsync(buffer);
+  let changed = false;
+  for (const [path2, entry] of Object.entries(zip.files)) {
+    if (!path2.match(/^ppt\/slides\/slide\d+\.xml$/)) continue;
+    const xml = await entry.async("string");
+    if (xml.includes(MEDIUM_STYLE_2_ACCENT_1)) {
+      zip.file(path2, xml.replaceAll(MEDIUM_STYLE_2_ACCENT_1, NO_STYLE_NO_GRID));
+      changed = true;
+    }
+  }
+  return changed ? await zip.generateAsync({ type: "nodebuffer" }) : buffer;
+}
+async function savePresentation(pptx, outputPath) {
+  const data = await pptx.write({ outputType: "nodebuffer" });
+  const buffer = await neutralizeTableStyle(data);
+  writeFileSync(outputPath, buffer);
+}
+var PresentationGenerator = {
+  generate: generatePresentation,
+  generateBufferFromJson,
+  generateBufferWithWarnings,
+  generateAndSaveFromJson,
+  generateFromFile,
+  save: savePresentation,
+  isPresentationComponentDefinition
+};
+
+// src/index.ts
+function getPptxCoreVersion() {
+  return "PptxCore v1.0.0";
+}
+export {
+  DEFAULT_PPTX_THEME,
+  PresentationGenerator,
+  W as WarningCodes,
+  generateAndSaveFromJson,
+  generateBufferFromJson,
+  generateBufferWithWarnings,
+  generateFromFile,
+  generatePresentation,
+  getPptxCoreVersion,
+  getPptxTheme,
+  isPresentationComponent,
+  isPresentationComponentDefinition,
+  isSlideComponent,
+  pptxThemes,
+  renderComponent,
+  renderHighchartsComponent,
+  renderImageComponent,
+  renderShapeComponent,
+  renderTableComponent,
+  renderTextComponent,
+  savePresentation
+};
+//# sourceMappingURL=index.js.map