pptx-craft 0.1.0

package/dist/index.js

@@ -0,0 +1,3878 @@
+// src/core/registry.ts
+var Registry = class {
+  serializers = /* @__PURE__ */ new Map();
+  registerElement(type, serializer) {
+    this.serializers.set(type, serializer);
+  }
+  getSerializer(type) {
+    return this.serializers.get(type);
+  }
+};
+
+// src/core/theme.ts
+var defaultColorScheme = {
+  dk1: "000000",
+  lt1: "FFFFFF",
+  dk2: "44546A",
+  lt2: "E7E6E6",
+  accent1: "4472C4",
+  accent2: "ED7D31",
+  accent3: "A5A5A5",
+  accent4: "FFC000",
+  accent5: "5B9BD5",
+  accent6: "70AD47",
+  hlink: "0563C1",
+  folHlink: "954F72"
+};
+var defaultFontScheme = {
+  majorFont: "Calibri Light",
+  minorFont: "Calibri"
+};
+var defaultTheme = {
+  name: "Office Theme",
+  colors: defaultColorScheme,
+  fonts: defaultFontScheme
+};
+
+// src/core/slide-master.ts
+var SlideMaster = class {
+  name;
+  background;
+  elements;
+  constructor(def) {
+    this.name = def.name;
+    this.background = def.background;
+    this.elements = def.elements ?? [];
+  }
+};
+
+// src/core/slide-layout.ts
+var SlideLayout = class {
+  name;
+  type;
+  placeholders;
+  constructor(def) {
+    this.name = def.name;
+    this.type = def.type ?? "blank";
+    this.placeholders = def.placeholders ?? [];
+  }
+};
+var builtinLayouts = {
+  blank: {
+    name: "Blank",
+    type: "blank",
+    placeholders: []
+  },
+  title: {
+    name: "Title Slide",
+    type: "title",
+    placeholders: [
+      { type: "ctrTitle", placement: { x: 0.69, y: 1.65, w: 8.63, h: 2.13 }, idx: 0 },
+      { type: "subTitle", placement: { x: 1.36, y: 4.08, w: 7.29, h: 1.68 }, idx: 1 }
+    ]
+  },
+  titleAndContent: {
+    name: "Title and Content",
+    type: "titleAndContent",
+    placeholders: [
+      { type: "title", placement: { x: 0.5, y: 0.28, w: 9, h: 1 }, idx: 0 },
+      { type: "body", placement: { x: 0.5, y: 1.53, w: 9, h: 5.47 }, idx: 1 }
+    ]
+  },
+  sectionHeader: {
+    name: "Section Header",
+    type: "sectionHeader",
+    placeholders: [
+      { type: "title", placement: { x: 0.69, y: 1.65, w: 8.63, h: 2.13 }, idx: 0 },
+      { type: "body", placement: { x: 0.69, y: 4.08, w: 8.63, h: 1.68 }, idx: 1 }
+    ]
+  },
+  twoContent: {
+    name: "Two Content",
+    type: "twoContent",
+    placeholders: [
+      { type: "title", placement: { x: 0.5, y: 0.28, w: 9, h: 1 }, idx: 0 },
+      { type: "body", placement: { x: 0.5, y: 1.53, w: 4.25, h: 5.47 }, idx: 1 },
+      { type: "body", placement: { x: 5.25, y: 1.53, w: 4.25, h: 5.47 }, idx: 2 }
+    ]
+  }
+};
+
+// src/core/notes-master.ts
+var NotesMaster = class {
+  name;
+  constructor(def) {
+    this.name = def?.name ?? "Default Notes Master";
+  }
+};
+
+// src/core/handout-master.ts
+var HandoutMaster = class {
+  name;
+  constructor(def) {
+    this.name = def?.name ?? "Default Handout Master";
+  }
+};
+
+// src/ooxml/xml.ts
+var AMP = /&/g;
+var LT = /</g;
+var GT = />/g;
+var QUOT = /"/g;
+var APOS = /'/g;
+function escapeXml(s) {
+  return s.replace(AMP, "&amp;").replace(LT, "&lt;").replace(GT, "&gt;").replace(QUOT, "&quot;").replace(APOS, "&apos;");
+}
+function tag(name, attrs, children) {
+  let s = `<${name}`;
+  if (attrs) {
+    for (const [k, v] of Object.entries(attrs)) {
+      if (v !== void 0) {
+        s += ` ${k}="${escapeXml(String(v))}"`;
+      }
+    }
+  }
+  if (children !== void 0 && children !== "") {
+    s += `>${children}</${name}>`;
+  } else {
+    s += "/>";
+  }
+  return s;
+}
+function openTag(name, attrs) {
+  let s = `<${name}`;
+  if (attrs) {
+    for (const [k, v] of Object.entries(attrs)) {
+      if (v !== void 0) {
+        s += ` ${k}="${escapeXml(String(v))}"`;
+      }
+    }
+  }
+  s += ">";
+  return s;
+}
+function closeTag(name) {
+  return `</${name}>`;
+}
+
+// src/ooxml/units.ts
+var EMU_PER_INCH = 914400;
+var EMU_PER_PT = 12700;
+function inchesToEmu(inches) {
+  return Math.round(inches * EMU_PER_INCH);
+}
+function ptToEmu(pt) {
+  return Math.round(pt * EMU_PER_PT);
+}
+function ptToHundredths(pt) {
+  return Math.round(pt * 100);
+}
+
+// src/ooxml/constants.ts
+var NAMESPACE = {
+  a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+  r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  p: "http://schemas.openxmlformats.org/presentationml/2006/main"
+};
+var CONTENT_TYPE = {
+  presentation: "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml",
+  slide: "application/vnd.openxmlformats-officedocument.presentationml.slide+xml",
+  slideLayout: "application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml",
+  slideMaster: "application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml",
+  theme: "application/vnd.openxmlformats-officedocument.theme+xml",
+  rels: "application/vnd.openxmlformats-package.relationships+xml",
+  coreProps: "application/vnd.openxmlformats-package.core-properties+xml",
+  appProps: "application/vnd.openxmlformats-officedocument.extended-properties+xml",
+  presProps: "application/vnd.openxmlformats-officedocument.presentationml.presProps+xml",
+  viewProps: "application/vnd.openxmlformats-officedocument.presentationml.viewProps+xml",
+  notesMaster: "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml",
+  notesSlide: "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml",
+  commentAuthors: "application/vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml",
+  comments: "application/vnd.openxmlformats-officedocument.presentationml.comments+xml",
+  handoutMaster: "application/vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml",
+  tags: "application/vnd.openxmlformats-officedocument.presentationml.tags+xml",
+  slideUpdateInfo: "application/vnd.openxmlformats-officedocument.presentationml.slideUpdateInfo+xml",
+  png: "image/png",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  svg: "image/svg+xml"
+};
+var REL_TYPE = {
+  slide: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide",
+  slideMaster: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster",
+  slideLayout: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout",
+  theme: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
+  image: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+  officeDocument: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+  coreProperties: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
+  extendedProperties: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
+  presProps: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/presProps",
+  viewProps: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/viewProps",
+  notesMaster: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster",
+  notesSlide: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide",
+  commentAuthors: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/commentAuthors",
+  comments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
+  handoutMaster: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/handoutMaster",
+  tags: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags",
+  slideUpdateInfo: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideUpdateInfo",
+  htmlPubSaveAs: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/htmlPubSaveAs",
+  slideUpdateUrl: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideUpdateUrl"
+};
+var DEFAULT_SLIDE_WIDTH = 10;
+var DEFAULT_SLIDE_HEIGHT = 7.5;
+
+// src/ooxml/serializers/shared.ts
+import { readFileSync } from "fs";
+
+// src/ooxml/serializers/color.ts
+function isSchemeColor(c) {
+  return typeof c === "object" && "scheme" in c;
+}
+function isSystemColor(c) {
+  return typeof c === "object" && "sys" in c;
+}
+function isPresetColor(c) {
+  return typeof c === "object" && "preset" in c;
+}
+function isHslColor(c) {
+  return typeof c === "object" && "hue" in c && "sat" in c && "lum" in c;
+}
+function isSrgbColor(c) {
+  return typeof c === "object" && "hex" in c;
+}
+function serializeTransforms(t) {
+  let xml = "";
+  if (t.tint !== void 0) xml += tag("a:tint", { val: t.tint });
+  if (t.shade !== void 0) xml += tag("a:shade", { val: t.shade });
+  if (t.satMod !== void 0) xml += tag("a:satMod", { val: t.satMod });
+  if (t.satOff !== void 0) xml += tag("a:satOff", { val: t.satOff });
+  if (t.lumMod !== void 0) xml += tag("a:lumMod", { val: t.lumMod });
+  if (t.lumOff !== void 0) xml += tag("a:lumOff", { val: t.lumOff });
+  if (t.hueMod !== void 0) xml += tag("a:hueMod", { val: t.hueMod });
+  if (t.hueOff !== void 0) xml += tag("a:hueOff", { val: t.hueOff });
+  if (t.alpha !== void 0) xml += tag("a:alpha", { val: Math.round(t.alpha * 1e3) });
+  if (t.alphaOff !== void 0) xml += tag("a:alphaOff", { val: Math.round(t.alphaOff * 1e3) });
+  return xml;
+}
+function serializeColor(color) {
+  if (typeof color === "string") {
+    return tag("a:srgbClr", { val: color });
+  }
+  if (isSchemeColor(color)) {
+    const children = color.transforms ? serializeTransforms(color.transforms) : void 0;
+    return tag("a:schemeClr", { val: color.scheme }, children);
+  }
+  if (isSystemColor(color)) {
+    const attrs = { val: color.sys };
+    if (color.lastClr) attrs.lastClr = color.lastClr;
+    const children = color.transforms ? serializeTransforms(color.transforms) : void 0;
+    return tag("a:sysClr", attrs, children);
+  }
+  if (isPresetColor(color)) {
+    const children = color.transforms ? serializeTransforms(color.transforms) : void 0;
+    return tag("a:prstClr", { val: color.preset }, children);
+  }
+  if (isHslColor(color)) {
+    const children = color.transforms ? serializeTransforms(color.transforms) : void 0;
+    return tag(
+      "a:hslClr",
+      {
+        hue: Math.round(color.hue * 6e4),
+        sat: Math.round(color.sat * 1e3),
+        lum: Math.round(color.lum * 1e3)
+      },
+      children
+    );
+  }
+  if (isSrgbColor(color)) {
+    const children = color.transforms ? serializeTransforms(color.transforms) : void 0;
+    return tag("a:srgbClr", { val: color.hex }, children);
+  }
+  return tag("a:srgbClr", { val: "000000" });
+}
+function serializeSolidFill(color) {
+  return tag("a:solidFill", void 0, serializeColor(color));
+}
+function serializeColorWithAlpha(color, alpha) {
+  if (alpha === void 0 || alpha >= 100) return serializeColor(color);
+  const alphaChild = tag("a:alpha", { val: Math.round(alpha * 1e3) });
+  if (typeof color === "string") {
+    return tag("a:srgbClr", { val: color }, alphaChild);
+  }
+  if (isSrgbColor(color)) {
+    let children = color.transforms ? serializeTransforms(color.transforms) : "";
+    children += alphaChild;
+    return tag("a:srgbClr", { val: color.hex }, children);
+  }
+  if (isSchemeColor(color)) {
+    let children = color.transforms ? serializeTransforms(color.transforms) : "";
+    children += alphaChild;
+    return tag("a:schemeClr", { val: color.scheme }, children);
+  }
+  if (isSystemColor(color)) {
+    const attrs = { val: color.sys };
+    if (color.lastClr) attrs.lastClr = color.lastClr;
+    let children = color.transforms ? serializeTransforms(color.transforms) : "";
+    children += alphaChild;
+    return tag("a:sysClr", attrs, children);
+  }
+  if (isPresetColor(color)) {
+    let children = color.transforms ? serializeTransforms(color.transforms) : "";
+    children += alphaChild;
+    return tag("a:prstClr", { val: color.preset }, children);
+  }
+  if (isHslColor(color)) {
+    let children = color.transforms ? serializeTransforms(color.transforms) : "";
+    children += alphaChild;
+    return tag(
+      "a:hslClr",
+      {
+        hue: Math.round(color.hue * 6e4),
+        sat: Math.round(color.sat * 1e3),
+        lum: Math.round(color.lum * 1e3)
+      },
+      children
+    );
+  }
+  return tag("a:srgbClr", { val: "000000" }, alphaChild);
+}
+
+// src/ooxml/serializers/shared.ts
+function isGradientFill(fill) {
+  return typeof fill === "object" && "stops" in fill && "type" in fill;
+}
+function isPatternFill(fill) {
+  return typeof fill === "object" && "pattern" in fill;
+}
+function isPictureFill(fill) {
+  return typeof fill === "object" && !isGradientFill(fill) && !isPatternFill(fill) && ("path" in fill || "data" in fill);
+}
+function serializeFill(fill, ctx) {
+  if (typeof fill === "string" || typeof fill === "object" && ("scheme" in fill || "sys" in fill || "preset" in fill || "hex" in fill || "hue" in fill && "sat" in fill && "lum" in fill)) {
+    return serializeSolidFill(fill);
+  }
+  if (isGradientFill(fill)) {
+    let stopsXml = "";
+    for (const stop of fill.stops) {
+      const pos = Math.round(stop.position * 1e3);
+      const clrXml = serializeColorWithAlpha(stop.color, stop.alpha);
+      stopsXml += tag("a:gs", { pos }, clrXml);
+    }
+    let dirChild = "";
+    if (fill.type === "linear") {
+      dirChild = tag("a:lin", { ang: Math.round((fill.angle ?? 0) * 6e4), scaled: "1" });
+    } else if (fill.type === "radial" || fill.type === "path") {
+      dirChild = tag(
+        "a:path",
+        { path: fill.type === "radial" ? "circle" : "rect" },
+        tag("a:fillToRect", { l: "50000", t: "50000", r: "50000", b: "50000" })
+      );
+    }
+    return tag("a:gradFill", void 0, tag("a:gsLst", void 0, stopsXml) + dirChild);
+  }
+  if (isPatternFill(fill)) {
+    return tag(
+      "a:pattFill",
+      { prst: fill.pattern },
+      tag("a:fgClr", void 0, serializeColor(fill.foreground)) + tag("a:bgClr", void 0, serializeColor(fill.background))
+    );
+  }
+  if (isPictureFill(fill) && ctx) {
+    let data = fill.data;
+    if (!data && fill.path) {
+      data = readFileSync(fill.path);
+    }
+    if (!data) return "";
+    const ct = fill.contentType ?? "image/png";
+    const ext = ct.split("/")[1] ?? "png";
+    const fileName = `fill_${Date.now()}.${ext}`;
+    const target = `../media/${fileName}`;
+    const rId = ctx.addRelationship(REL_TYPE.image, target, data);
+    let content = tag("a:blip", { "r:embed": rId });
+    if (fill.tile) {
+      content += tag("a:tile", {
+        sx: fill.tile.sx,
+        sy: fill.tile.sy,
+        tx: fill.tile.tx,
+        ty: fill.tile.ty
+      });
+    } else {
+      content += tag("a:stretch", void 0, tag("a:fillRect"));
+    }
+    return tag("a:blipFill", void 0, content);
+  }
+  return "";
+}
+function serializeLine(line) {
+  const attrs = {};
+  if (line.width) attrs.w = ptToEmu(line.width);
+  if (line.cap) attrs.cap = line.cap === "square" ? "sq" : line.cap;
+  if (line.compound) attrs.cmpd = line.compound;
+  if (line.alignment) attrs.algn = line.alignment;
+  let children = "";
+  if (line.fill) {
+    children += serializeFill(line.fill);
+  } else if (line.color) {
+    children += tag("a:solidFill", void 0, serializeColorWithAlpha(line.color, line.opacity));
+  }
+  if (line.customDash && line.customDash.length > 0) {
+    let dashChildren = "";
+    for (const seg of line.customDash) {
+      dashChildren += tag("a:ds", { d: seg.d, sp: seg.sp });
+    }
+    children += tag("a:custDash", void 0, dashChildren);
+  } else if (line.dash && line.dash !== "solid") {
+    children += tag("a:prstDash", { val: line.dash });
+  }
+  if (line.join) {
+    if (line.join === "round") children += tag("a:round");
+    else if (line.join === "bevel") children += tag("a:bevel");
+    else children += tag("a:miter", { lim: "800000" });
+  }
+  if (line.headEnd) {
+    const hAttrs = {};
+    if (line.headEnd.type) hAttrs.type = line.headEnd.type;
+    if (line.headEnd.width) hAttrs.w = line.headEnd.width;
+    if (line.headEnd.length) hAttrs.len = line.headEnd.length;
+    children += tag("a:headEnd", hAttrs);
+  }
+  if (line.tailEnd) {
+    const tAttrs = {};
+    if (line.tailEnd.type) tAttrs.type = line.tailEnd.type;
+    if (line.tailEnd.width) tAttrs.w = line.tailEnd.width;
+    if (line.tailEnd.length) tAttrs.len = line.tailEnd.length;
+    children += tag("a:tailEnd", tAttrs);
+  }
+  return tag("a:ln", attrs, children || void 0);
+}
+function serializeShadow(shadow) {
+  const isInner = shadow.type === "inner";
+  const elName = isInner ? "a:innerShdw" : "a:outerShdw";
+  const attrs = {};
+  if (shadow.blur) attrs.blurRad = ptToEmu(shadow.blur);
+  if (shadow.offset) attrs.dist = ptToEmu(shadow.offset);
+  if (shadow.angle !== void 0) attrs.dir = Math.round(shadow.angle * 6e4);
+  const color = shadow.color ?? "000000";
+  return tag(elName, attrs, serializeColorWithAlpha(color, shadow.alpha));
+}
+function serializeGlow(glow) {
+  const attrs = {};
+  if (glow.radius) attrs.rad = ptToEmu(glow.radius);
+  const color = glow.color ?? "FFC000";
+  return tag("a:glow", attrs, serializeColorWithAlpha(color, glow.alpha));
+}
+function serializeReflection(refl) {
+  const attrs = {};
+  if (refl.blur) attrs.blurRad = ptToEmu(refl.blur);
+  if (refl.startAlpha !== void 0) attrs.stA = Math.round(refl.startAlpha * 1e3);
+  if (refl.endAlpha !== void 0) attrs.endA = Math.round(refl.endAlpha * 1e3);
+  if (refl.distance) attrs.dist = ptToEmu(refl.distance);
+  if (refl.direction !== void 0) attrs.dir = Math.round(refl.direction * 6e4);
+  if (refl.fadeDirection !== void 0) attrs.fadeDir = Math.round(refl.fadeDirection * 6e4);
+  return tag("a:reflection", attrs);
+}
+function serializeSoftEdge(se) {
+  const attrs = {};
+  if (se.radius) attrs.rad = ptToEmu(se.radius);
+  return tag("a:softEdge", attrs);
+}
+function serializeEffects(effects) {
+  let children = "";
+  if (effects.glow) children += serializeGlow(effects.glow);
+  if (effects.shadow) children += serializeShadow(effects.shadow);
+  if (effects.reflection) children += serializeReflection(effects.reflection);
+  if (effects.softEdge) children += serializeSoftEdge(effects.softEdge);
+  if (!children) return "";
+  return tag("a:effectLst", void 0, children);
+}
+function serializeTransform(placement, transform) {
+  const xfrmAttrs = {};
+  const rot = placement.rotation ?? transform?.rotation;
+  if (rot) xfrmAttrs.rot = Math.round(rot * 6e4);
+  if (transform?.flipH) xfrmAttrs.flipH = "1";
+  if (transform?.flipV) xfrmAttrs.flipV = "1";
+  return tag(
+    "a:xfrm",
+    Object.keys(xfrmAttrs).length > 0 ? xfrmAttrs : void 0,
+    tag("a:off", { x: inchesToEmu(placement.x), y: inchesToEmu(placement.y) }) + tag("a:ext", { cx: inchesToEmu(placement.w), cy: inchesToEmu(placement.h) })
+  );
+}
+var HYPERLINK_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+function serializeHyperlink(link, ctx) {
+  if (link.url) {
+    const rId = ctx.addRelationship(HYPERLINK_REL_TYPE, link.url);
+    const attrs = { "r:id": rId };
+    if (link.tooltip) attrs.tooltip = link.tooltip;
+    return tag("a:hlinkClick", attrs);
+  }
+  if (link.email) {
+    const rId = ctx.addRelationship(HYPERLINK_REL_TYPE, `mailto:${link.email}`);
+    const attrs = { "r:id": rId };
+    if (link.tooltip) attrs.tooltip = link.tooltip;
+    return tag("a:hlinkClick", attrs);
+  }
+  if (link.file) {
+    const rId = ctx.addRelationship(HYPERLINK_REL_TYPE, link.file);
+    const attrs = { "r:id": rId };
+    if (link.tooltip) attrs.tooltip = link.tooltip;
+    return tag("a:hlinkClick", attrs);
+  }
+  if (link.action) {
+    const attrs = { action: link.action };
+    if (link.tooltip) attrs.tooltip = link.tooltip;
+    return tag("a:hlinkClick", attrs);
+  }
+  if (link.slide !== void 0) {
+    const attrs = { action: "ppaction://hlinksldjump" };
+    if (link.tooltip) attrs.tooltip = link.tooltip;
+    return tag("a:hlinkClick", attrs);
+  }
+  return "";
+}
+
+// src/ooxml/serializers/scene3d.ts
+function serializeScene3D(scene) {
+  let children = "";
+  if (scene.camera) {
+    const attrs = {
+      prst: scene.camera.preset ?? "orthographicFront"
+    };
+    if (scene.camera.fov !== void 0) attrs.fov = Math.round(scene.camera.fov * 6e4);
+    children += tag("a:camera", attrs);
+  } else {
+    children += tag("a:camera", { prst: "orthographicFront" });
+  }
+  if (scene.lightRig) {
+    const attrs = {
+      rig: scene.lightRig.type ?? "threePt",
+      dir: scene.lightRig.direction ?? "t"
+    };
+    children += tag("a:lightRig", attrs);
+  } else {
+    children += tag("a:lightRig", { rig: "threePt", dir: "t" });
+  }
+  return tag("a:scene3d", void 0, children);
+}
+function serializeShape3D(sp3d) {
+  const attrs = {};
+  if (sp3d.extrusionHeight !== void 0)
+    attrs.extrusionH = Math.round(sp3d.extrusionHeight * 12700);
+  if (sp3d.contourWidth !== void 0) attrs.contourW = Math.round(sp3d.contourWidth * 12700);
+  if (sp3d.material) attrs.prstMaterial = sp3d.material;
+  let children = "";
+  if (sp3d.bevelTop) {
+    const bAttrs = {};
+    if (sp3d.bevelTop.width !== void 0) bAttrs.w = Math.round(sp3d.bevelTop.width * 12700);
+    if (sp3d.bevelTop.height !== void 0) bAttrs.h = Math.round(sp3d.bevelTop.height * 12700);
+    if (sp3d.bevelTop.preset) bAttrs.prst = sp3d.bevelTop.preset;
+    children += tag("a:bevelT", bAttrs);
+  }
+  if (sp3d.bevelBottom) {
+    const bAttrs = {};
+    if (sp3d.bevelBottom.width !== void 0) bAttrs.w = Math.round(sp3d.bevelBottom.width * 12700);
+    if (sp3d.bevelBottom.height !== void 0)
+      bAttrs.h = Math.round(sp3d.bevelBottom.height * 12700);
+    if (sp3d.bevelBottom.preset) bAttrs.prst = sp3d.bevelBottom.preset;
+    children += tag("a:bevelB", bAttrs);
+  }
+  if (sp3d.extrusionColor) {
+    children += tag("a:extrusionClr", void 0, serializeColor(sp3d.extrusionColor));
+  }
+  if (sp3d.contourColor) {
+    children += tag("a:contourClr", void 0, serializeColor(sp3d.contourColor));
+  }
+  return tag("a:sp3d", Object.keys(attrs).length > 0 ? attrs : void 0, children || void 0);
+}
+
+// src/ooxml/serializers/text.ts
+function serializeSpacing(val) {
+  if (typeof val === "number") {
+    return tag("a:spcPts", { val: ptToHundredths(val) });
+  }
+  if (val.unit === "pct") {
+    return tag("a:spcPct", { val: Math.round(val.value * 1e3) });
+  }
+  return tag("a:spcPts", { val: ptToHundredths(val.value) });
+}
+function serializeRunProps(run, ctx) {
+  const o = run.options;
+  if (!o) return "";
+  const attrs = {};
+  if (o.fontSize) attrs.sz = ptToHundredths(o.fontSize);
+  if (o.bold) attrs.b = "1";
+  if (o.italic) attrs.i = "1";
+  if (o.underline) attrs.u = "sng";
+  if (o.strikethrough) {
+    attrs.strike = o.strikethrough === "double" ? "dblStrike" : "sngStrike";
+  }
+  if (o.caps === "small") attrs.cap = "small";
+  else if (o.caps === "all") attrs.cap = "all";
+  if (o.letterSpacing) attrs.spc = Math.round(o.letterSpacing * 100);
+  if (o.lang) attrs.lang = o.lang;
+  if (o.altLang) attrs.altLang = o.altLang;
+  if (o.subscript) attrs.baseline = "-40000";
+  else if (o.superscript) attrs.baseline = "30000";
+  else if (o.baseline !== void 0) attrs.baseline = String(Math.round(o.baseline * 1e3));
+  let children = "";
+  if (o.color) children += serializeSolidFill(o.color);
+  if (o.highlight) children += tag("a:highlight", void 0, serializeColor(o.highlight));
+  if (o.fontFace) children += tag("a:latin", { typeface: o.fontFace });
+  if (o.eastAsianFont) children += tag("a:ea", { typeface: o.eastAsianFont });
+  if (o.complexScriptFont) children += tag("a:cs", { typeface: o.complexScriptFont });
+  if (o.outline) children += serializeLine(o.outline);
+  if (o.shadow) {
+    const sAttrs = {};
+    if (o.shadow.blur) sAttrs.blurRad = ptToEmu(o.shadow.blur);
+    if (o.shadow.offset) sAttrs.dist = ptToEmu(o.shadow.offset);
+    if (o.shadow.angle !== void 0) sAttrs.dir = Math.round(o.shadow.angle * 6e4);
+    const sc = o.shadow.color ?? "000000";
+    children += tag(
+      "a:effectLst",
+      void 0,
+      tag("a:outerShdw", sAttrs, serializeColorWithAlpha(sc, o.shadow.alpha))
+    );
+  }
+  if (o.hyperlink) children += serializeHyperlink(o.hyperlink, ctx);
+  if (children) return tag("a:rPr", attrs, children);
+  if (Object.keys(attrs).length > 0) return tag("a:rPr", attrs);
+  return "";
+}
+function serializeDefRunProps(o) {
+  const attrs = {};
+  if (o.fontSize) attrs.sz = ptToHundredths(o.fontSize);
+  if (o.bold) attrs.b = "1";
+  if (o.italic) attrs.i = "1";
+  let children = "";
+  if (o.color) children += serializeSolidFill(o.color);
+  if (o.fontFace) children += tag("a:latin", { typeface: o.fontFace });
+  return tag("a:defRPr", attrs, children || void 0);
+}
+function serializeParagraph(para, ctx) {
+  let xml = openTag("a:p");
+  const pOpts = para.options;
+  if (pOpts) {
+    const attrs = {};
+    if (pOpts.align) {
+      const map = { left: "l", center: "ctr", right: "r", justify: "just" };
+      attrs.algn = map[pOpts.align] ?? "l";
+    }
+    if (pOpts.level !== void 0) attrs.lvl = pOpts.level;
+    if (pOpts.indent) attrs.indent = ptToEmu(pOpts.indent);
+    if (pOpts.marginLeft) attrs.marL = ptToEmu(pOpts.marginLeft);
+    if (pOpts.rtl) attrs.rtl = "1";
+    let pPrChildren = "";
+    if (pOpts.lineSpacing) {
+      pPrChildren += tag("a:lnSpc", void 0, serializeSpacing(pOpts.lineSpacing));
+    }
+    if (pOpts.spaceBefore) {
+      pPrChildren += tag("a:spcBef", void 0, serializeSpacing(pOpts.spaceBefore));
+    }
+    if (pOpts.spaceAfter) {
+      pPrChildren += tag("a:spcAft", void 0, serializeSpacing(pOpts.spaceAfter));
+    }
+    if (pOpts.bullet) {
+      if (pOpts.bullet === true) {
+        pPrChildren += tag("a:buChar", { char: "\u2022" });
+      } else {
+        if (pOpts.bullet.color) {
+          pPrChildren += tag("a:buClr", void 0, serializeColor(pOpts.bullet.color));
+        }
+        if (pOpts.bullet.size) {
+          pPrChildren += tag("a:buSzPct", { val: Math.round(pOpts.bullet.size * 1e3) });
+        }
+        if (pOpts.bullet.font) {
+          pPrChildren += tag("a:buFont", { typeface: pOpts.bullet.font });
+        }
+        if (pOpts.bullet.type === "auto") {
+          pPrChildren += tag("a:buAutoNum", { type: "arabicPeriod" });
+        } else {
+          pPrChildren += tag("a:buChar", { char: pOpts.bullet.char ?? "\u2022" });
+        }
+      }
+    } else if (pOpts.numbering) {
+      if (pOpts.numbering.color) {
+        pPrChildren += tag("a:buClr", void 0, serializeColor(pOpts.numbering.color));
+      }
+      if (pOpts.numbering.size) {
+        pPrChildren += tag("a:buSzPct", { val: Math.round(pOpts.numbering.size * 1e3) });
+      }
+      if (pOpts.numbering.font) {
+        pPrChildren += tag("a:buFont", { typeface: pOpts.numbering.font });
+      }
+      const numAttrs = {
+        type: pOpts.numbering.type ?? "arabicPeriod"
+      };
+      if (pOpts.numbering.startAt) numAttrs.startAt = pOpts.numbering.startAt;
+      pPrChildren += tag("a:buAutoNum", numAttrs);
+    }
+    if (pOpts.tabStops) {
+      let tabsXml = "";
+      for (const ts of pOpts.tabStops) {
+        const tsAttrs = { pos: ptToEmu(ts.position) };
+        if (ts.alignment) tsAttrs.algn = ts.alignment;
+        tabsXml += tag("a:tab", tsAttrs);
+      }
+      pPrChildren += tag("a:tabLst", void 0, tabsXml);
+    }
+    if (pOpts.defaultRunOptions) {
+      pPrChildren += serializeDefRunProps(pOpts.defaultRunOptions);
+    }
+    xml += tag("a:pPr", attrs, pPrChildren || void 0);
+  }
+  for (const run of para.runs) {
+    xml += openTag("a:r");
+    xml += serializeRunProps(run, ctx);
+    xml += tag("a:t", void 0, run.text);
+    xml += closeTag("a:r");
+  }
+  xml += closeTag("a:p");
+  return xml;
+}
+function serializeBodyPr(bodyOpts) {
+  const attrs = { wrap: "square", rtlCol: "0" };
+  if (bodyOpts) {
+    if (bodyOpts.verticalAlign) {
+      const map = { top: "t", middle: "ctr", bottom: "b" };
+      attrs.anchor = map[bodyOpts.verticalAlign] ?? "t";
+    }
+    if (bodyOpts.textDirection) {
+      const map = {
+        horz: "horz",
+        vert: "vert",
+        vert270: "vert270",
+        wordArtVert: "wordArtVert"
+      };
+      if (map[bodyOpts.textDirection]) attrs.vert = map[bodyOpts.textDirection];
+    }
+    if (bodyOpts.wordWrap === false) attrs.wrap = "none";
+    if (bodyOpts.columns && bodyOpts.columns > 1) attrs.numCol = bodyOpts.columns;
+    if (bodyOpts.columnSpacing) attrs.spcCol = ptToEmu(bodyOpts.columnSpacing);
+    if (bodyOpts.margin) {
+      if (bodyOpts.margin.top !== void 0) attrs.tIns = ptToEmu(bodyOpts.margin.top);
+      if (bodyOpts.margin.bottom !== void 0) attrs.bIns = ptToEmu(bodyOpts.margin.bottom);
+      if (bodyOpts.margin.left !== void 0) attrs.lIns = ptToEmu(bodyOpts.margin.left);
+      if (bodyOpts.margin.right !== void 0) attrs.rIns = ptToEmu(bodyOpts.margin.right);
+    }
+  }
+  let children = "";
+  if (bodyOpts?.autoFit === true || bodyOpts?.autoFit === "shrink") {
+    children += tag("a:normAutofit");
+  } else if (bodyOpts?.autoFit === "none") {
+    children += tag("a:noAutofit");
+  }
+  if (bodyOpts?.textPath) {
+    children += tag("a:prstTxWarp", { prst: bodyOpts.textPath.preset }, tag("a:avLst"));
+  }
+  return tag("a:bodyPr", attrs, children || void 0);
+}
+var textSerializer = {
+  type: "text",
+  serialize(element, ctx) {
+    const p = element.placement;
+    let xml = openTag("p:sp");
+    xml += tag(
+      "p:nvSpPr",
+      void 0,
+      tag("p:cNvPr", { id: "0", name: element.name ?? "" }) + tag("p:cNvSpPr", { txBox: "1" }) + tag("p:nvPr")
+    );
+    xml += openTag("p:spPr");
+    xml += serializeTransform(p, element.transform);
+    xml += tag("a:prstGeom", { prst: "rect" }, tag("a:avLst"));
+    if (element.fill) xml += serializeFill(element.fill, ctx);
+    if (element.line) xml += serializeLine(element.line);
+    if (element.effects) xml += serializeEffects(element.effects);
+    if (element.scene3d) xml += serializeScene3D(element.scene3d);
+    if (element.shape3d) xml += serializeShape3D(element.shape3d);
+    xml += closeTag("p:spPr");
+    xml += openTag("p:txBody");
+    xml += serializeBodyPr(element.bodyOptions);
+    xml += tag("a:lstStyle");
+    for (const para of element.paragraphs) {
+      xml += serializeParagraph(para, ctx);
+    }
+    xml += closeTag("p:txBody");
+    xml += closeTag("p:sp");
+    return xml;
+  }
+};
+
+// src/ooxml/serializers/image.ts
+import { readFileSync as readFileSync2 } from "fs";
+var imageCounter = 0;
+var imageSerializer = {
+  type: "image",
+  serialize(element, ctx) {
+    imageCounter++;
+    const ext = element.contentType.split("/")[1] ?? "png";
+    const fileName = `image${imageCounter}.${ext}`;
+    const target = `../media/${fileName}`;
+    let data = element.data;
+    if (!data && element.path) {
+      data = readFileSync2(element.path);
+    }
+    if (!data) throw new Error("Image element must have data or path");
+    const rId = ctx.addRelationship(REL_TYPE.image, target, data);
+    const p = element.placement;
+    let xml = openTag("p:pic");
+    let cNvPrChildren = "";
+    if (element.hyperlink) {
+      cNvPrChildren = serializeHyperlink(element.hyperlink, ctx);
+    }
+    const lockAspect = element.lockAspectRatio !== false;
+    xml += tag(
+      "p:nvPicPr",
+      void 0,
+      tag("p:cNvPr", { id: "0", name: element.name ?? fileName }, cNvPrChildren || void 0) + tag(
+        "p:cNvPicPr",
+        void 0,
+        tag("a:picLocks", { noChangeAspect: lockAspect ? "1" : "0" })
+      ) + tag("p:nvPr")
+    );
+    let blipChildren = "";
+    if (element.opacity !== void 0 && element.opacity < 100) {
+      blipChildren += tag("a:alphaModFix", { amt: Math.round(element.opacity * 1e3) });
+    }
+    if (element.brightness !== void 0 || element.contrast !== void 0) {
+      const lumAttrs = {};
+      if (element.brightness !== void 0) lumAttrs.bright = element.brightness * 1e3;
+      if (element.contrast !== void 0) lumAttrs.contrast = element.contrast * 1e3;
+      blipChildren += tag("a:lum", lumAttrs);
+    }
+    if (element.saturation !== void 0) {
+      blipChildren += tag("a:saturation", { sat: Math.round(element.saturation * 1e3) });
+    }
+    if (element.duotone) {
+      blipChildren += tag(
+        "a:duotone",
+        void 0,
+        serializeColor(element.duotone.color1) + serializeColor(element.duotone.color2)
+      );
+    }
+    let fillContent = tag("a:blip", { "r:embed": rId }, blipChildren || void 0);
+    if (element.crop) {
+      const cropAttrs = {};
+      if (element.crop.top) cropAttrs.t = Math.round(element.crop.top * 1e3);
+      if (element.crop.bottom) cropAttrs.b = Math.round(element.crop.bottom * 1e3);
+      if (element.crop.left) cropAttrs.l = Math.round(element.crop.left * 1e3);
+      if (element.crop.right) cropAttrs.r = Math.round(element.crop.right * 1e3);
+      fillContent += tag("a:srcRect", cropAttrs);
+    }
+    fillContent += tag("a:stretch", void 0, tag("a:fillRect"));
+    xml += tag("p:blipFill", void 0, fillContent);
+    xml += openTag("p:spPr");
+    xml += serializeTransform(p, element.transform);
+    xml += tag("a:prstGeom", { prst: element.cropShape ?? "rect" }, tag("a:avLst"));
+    if (element.border) xml += serializeLine(element.border);
+    if (element.effects) xml += serializeEffects(element.effects);
+    if (element.scene3d) xml += serializeScene3D(element.scene3d);
+    if (element.shape3d) xml += serializeShape3D(element.shape3d);
+    xml += closeTag("p:spPr");
+    xml += closeTag("p:pic");
+    return xml;
+  }
+};
+
+// src/ooxml/serializers/shape.ts
+var GEOMETRY_MAP = {
+  rect: "rect",
+  roundRect: "roundRect",
+  ellipse: "ellipse",
+  triangle: "triangle",
+  diamond: "diamond",
+  line: "line",
+  arrow: "rightArrow",
+  star5: "star5",
+  heart: "heart"
+};
+function serializeCustomGeometry(geom) {
+  let pathLst = "";
+  for (const path of geom.paths) {
+    const pathAttrs = {};
+    if (path.w !== void 0) pathAttrs.w = path.w;
+    if (path.h !== void 0) pathAttrs.h = path.h;
+    let cmds = "";
+    for (const cmd of path.commands) {
+      switch (cmd.type) {
+        case "moveTo":
+          cmds += tag("a:moveTo", void 0, tag("a:pt", { x: cmd.x, y: cmd.y }));
+          break;
+        case "lineTo":
+          cmds += tag("a:lnTo", void 0, tag("a:pt", { x: cmd.x, y: cmd.y }));
+          break;
+        case "arcTo":
+          cmds += tag("a:arcTo", { wR: cmd.wR, hR: cmd.hR, stAng: cmd.stAng, swAng: cmd.swAng });
+          break;
+        case "cubicBezTo":
+          cmds += tag(
+            "a:cubicBezTo",
+            void 0,
+            tag("a:pt", { x: cmd.x1, y: cmd.y1 }) + tag("a:pt", { x: cmd.x2, y: cmd.y2 }) + tag("a:pt", { x: cmd.x, y: cmd.y })
+          );
+          break;
+        case "close":
+          cmds += tag("a:close");
+          break;
+      }
+    }
+    pathLst += tag("a:path", Object.keys(pathAttrs).length > 0 ? pathAttrs : void 0, cmds);
+  }
+  return tag("a:custGeom", void 0, tag("a:avLst") + tag("a:pathLst", void 0, pathLst));
+}
+function serializeShapeLocks(locks) {
+  const attrs = {};
+  if (locks.noGroup) attrs.noGrp = "1";
+  if (locks.noRotation) attrs.noRot = "1";
+  if (locks.noMove) attrs.noMove = "1";
+  if (locks.noResize) attrs.noResize = "1";
+  if (locks.noSelect) attrs.noSelect = "1";
+  if (locks.noTextEdit) attrs.noTextEdit = "1";
+  return tag("a:spLocks", attrs);
+}
+var shapeSerializer = {
+  type: "shape",
+  serialize(element, ctx) {
+    const p = element.placement;
+    const prst = GEOMETRY_MAP[element.geometry] ?? element.geometry;
+    let xml = openTag("p:sp");
+    let cNvPrChildren = "";
+    if (element.hyperlink) {
+      cNvPrChildren = serializeHyperlink(element.hyperlink, ctx);
+    }
+    let cNvSpPrChildren = "";
+    if (element.locks) {
+      cNvSpPrChildren = serializeShapeLocks(element.locks);
+    }
+    xml += tag(
+      "p:nvSpPr",
+      void 0,
+      tag("p:cNvPr", { id: "0", name: element.name ?? "" }, cNvPrChildren || void 0) + tag("p:cNvSpPr", void 0, cNvSpPrChildren || void 0) + tag("p:nvPr")
+    );
+    xml += openTag("p:spPr");
+    xml += serializeTransform(p, element.transform);
+    if (element.customGeometry) {
+      xml += serializeCustomGeometry(element.customGeometry);
+    } else {
+      let avLstXml = "";
+      if (element.adjustValues) {
+        for (const [name, val] of Object.entries(element.adjustValues)) {
+          avLstXml += tag("a:gd", { name, fmla: `val ${val}` });
+        }
+      }
+      xml += tag(
+        "a:prstGeom",
+        { prst },
+        avLstXml ? tag("a:avLst", void 0, avLstXml) : tag("a:avLst")
+      );
+    }
+    if (element.fill) {
+      xml += serializeFill(element.fill, ctx);
+    }
+    if (element.line) {
+      xml += serializeLine(element.line);
+    }
+    if (element.effects) {
+      xml += serializeEffects(element.effects);
+    }
+    if (element.scene3d) {
+      xml += serializeScene3D(element.scene3d);
+    }
+    if (element.shape3d) {
+      xml += serializeShape3D(element.shape3d);
+    }
+    xml += closeTag("p:spPr");
+    if (element.text) {
+      xml += openTag("p:txBody");
+      const bodyAttrs = { wrap: "square", rtlCol: "0" };
+      if (element.textOptions) {
+        if (element.textOptions.verticalAlign) {
+          const map = { top: "t", middle: "ctr", bottom: "b" };
+          bodyAttrs.anchor = map[element.textOptions.verticalAlign] ?? "t";
+        }
+        if (element.textOptions.wordWrap === false) bodyAttrs.wrap = "none";
+        if (element.textOptions.margin) {
+          if (element.textOptions.margin.top !== void 0)
+            bodyAttrs.tIns = ptToEmu(element.textOptions.margin.top);
+          if (element.textOptions.margin.bottom !== void 0)
+            bodyAttrs.bIns = ptToEmu(element.textOptions.margin.bottom);
+          if (element.textOptions.margin.left !== void 0)
+            bodyAttrs.lIns = ptToEmu(element.textOptions.margin.left);
+          if (element.textOptions.margin.right !== void 0)
+            bodyAttrs.rIns = ptToEmu(element.textOptions.margin.right);
+        }
+      }
+      let bodyChildren = "";
+      if (element.textOptions?.autoFit === true || element.textOptions?.autoFit === "shrink") {
+        bodyChildren = tag("a:normAutofit");
+      } else if (element.textOptions?.autoFit === "none") {
+        bodyChildren = tag("a:noAutofit");
+      }
+      xml += tag("a:bodyPr", bodyAttrs, bodyChildren || void 0);
+      xml += tag("a:lstStyle");
+      const lines = element.text.split("\n");
+      for (const line of lines) {
+        xml += serializeParagraph(
+          {
+            runs: [{ text: line, options: element.textRunOptions }],
+            options: element.textParagraphOptions
+          },
+          ctx
+        );
+      }
+      xml += closeTag("p:txBody");
+    }
+    xml += closeTag("p:sp");
+    return xml;
+  }
+};
+
+// src/ooxml/serializers/table.ts
+function serializeBorderLine(b, defaultWidth) {
+  const bw = b.width ? ptToEmu(b.width) : defaultWidth ?? 12700;
+  const bc = b.color ?? "000000";
+  return tag("a:ln", { w: bw }, serializeSolidFill(bc));
+}
+function serializeCellBorders(cell, _tableBorder) {
+  const o = cell.options;
+  let xml = "";
+  const sides = [
+    { cellKey: "borderLeft", tblKey: "left", elName: "a:lnL" },
+    { cellKey: "borderRight", tblKey: "right", elName: "a:lnR" },
+    { cellKey: "borderTop", tblKey: "top", elName: "a:lnT" },
+    { cellKey: "borderBottom", tblKey: "bottom", elName: "a:lnB" }
+  ];
+  for (const side of sides) {
+    const cellBorder = o?.[side.cellKey];
+    if (cellBorder) {
+      xml += tag(side.elName, void 0, serializeBorderLine(cellBorder));
+    }
+  }
+  return xml;
+}
+function serializeCell(cell, tableBorder, ctx) {
+  const o = cell.options;
+  const tcAttrs = {};
+  if (o?.colSpan && o.colSpan > 1) tcAttrs.gridSpan = o.colSpan;
+  if (o?.rowSpan && o.rowSpan > 1) tcAttrs.rowSpan = o.rowSpan;
+  let xml = openTag("a:tc", Object.keys(tcAttrs).length > 0 ? tcAttrs : void 0);
+  xml += openTag("a:txBody");
+  {
+    const bodyAttrs = {};
+    if (o?.textBody) {
+      if (o.textBody.verticalAlign) {
+        const m = { top: "t", middle: "ctr", bottom: "b" };
+        bodyAttrs.anchor = m[o.textBody.verticalAlign] ?? "t";
+      }
+      if (o.textBody.wordWrap === false) bodyAttrs.wrap = "none";
+      if (o.textBody.margin) {
+        if (o.textBody.margin.top !== void 0) bodyAttrs.tIns = ptToEmu(o.textBody.margin.top);
+        if (o.textBody.margin.bottom !== void 0)
+          bodyAttrs.bIns = ptToEmu(o.textBody.margin.bottom);
+        if (o.textBody.margin.left !== void 0) bodyAttrs.lIns = ptToEmu(o.textBody.margin.left);
+        if (o.textBody.margin.right !== void 0)
+          bodyAttrs.rIns = ptToEmu(o.textBody.margin.right);
+      }
+    }
+    xml += tag("a:bodyPr", Object.keys(bodyAttrs).length > 0 ? bodyAttrs : void 0);
+  }
+  xml += tag("a:lstStyle");
+  xml += openTag("a:p");
+  if (o?.align) {
+    const map = { left: "l", center: "ctr", right: "r", justify: "just" };
+    xml += tag("a:pPr", { algn: map[o.align] ?? "l" });
+  }
+  xml += openTag("a:r");
+  const rAttrs = {};
+  if (o?.fontSize) rAttrs.sz = ptToHundredths(o.fontSize);
+  if (o?.bold) rAttrs.b = "1";
+  if (o?.italic) rAttrs.i = "1";
+  if (o?.underline) rAttrs.u = "sng";
+  if (o?.strikethrough) {
+    rAttrs.strike = o.strikethrough === "double" ? "dblStrike" : "sngStrike";
+  }
+  let rPrChildren = "";
+  if (o?.color) rPrChildren += serializeSolidFill(o.color);
+  if (o?.fontFace) rPrChildren += tag("a:latin", { typeface: o.fontFace });
+  xml += tag("a:rPr", { lang: "en-US", ...rAttrs }, rPrChildren || void 0);
+  xml += tag("a:t", void 0, cell.text);
+  xml += closeTag("a:r");
+  xml += closeTag("a:p");
+  xml += closeTag("a:txBody");
+  let tcPr = "";
+  const tcPrAttrs = {};
+  if (o?.verticalAlign) {
+    const map = {
+      top: "t",
+      middle: "ctr",
+      bottom: "b",
+      distributed: "dist"
+    };
+    tcPrAttrs.anchor = map[o.verticalAlign] ?? "t";
+  }
+  tcPr += serializeCellBorders(cell, tableBorder);
+  if (o?.fill) {
+    tcPr += serializeFill(o.fill, ctx);
+  }
+  if (o?.margin) {
+    if (o.margin.top !== void 0) tcPrAttrs.marT = String(ptToEmu(o.margin.top));
+    if (o.margin.bottom !== void 0) tcPrAttrs.marB = String(ptToEmu(o.margin.bottom));
+    if (o.margin.left !== void 0) tcPrAttrs.marL = String(ptToEmu(o.margin.left));
+    if (o.margin.right !== void 0) tcPrAttrs.marR = String(ptToEmu(o.margin.right));
+  }
+  xml += tag(
+    "a:tcPr",
+    Object.keys(tcPrAttrs).length > 0 ? tcPrAttrs : void 0,
+    tcPr || void 0
+  );
+  xml += closeTag("a:tc");
+  return xml;
+}
+function serializeTableBorders(border) {
+  const bw = border.width ? ptToEmu(border.width) : 12700;
+  const bc = border.color ?? "000000";
+  const defaultLine = tag("a:ln", { w: bw }, serializeSolidFill(bc));
+  const sides = [
+    { key: "left", elName: "a:left" },
+    { key: "right", elName: "a:right" },
+    { key: "top", elName: "a:top" },
+    { key: "bottom", elName: "a:bottom" },
+    { key: "insideH", elName: "a:insideH" },
+    { key: "insideV", elName: "a:insideV" }
+  ];
+  let xml = "";
+  for (const side of sides) {
+    const override = border[side.key];
+    if (typeof override === "object" && override !== null && "color" in override) {
+      xml += tag(side.elName, void 0, serializeBorderLine(override));
+    } else {
+      xml += tag(side.elName, void 0, defaultLine);
+    }
+  }
+  return xml;
+}
+var tableSerializer = {
+  type: "table",
+  serialize(element, ctx) {
+    const p = element.placement;
+    const numCols = element.rows[0]?.length ?? 0;
+    let xml = openTag("p:graphicFrame");
+    xml += tag(
+      "p:nvGraphicFramePr",
+      void 0,
+      tag("p:cNvPr", { id: "0", name: element.name ?? "Table" }) + tag("p:cNvGraphicFramePr", void 0, tag("a:graphicFrameLocks", { noGrp: "1" })) + tag("p:nvPr")
+    );
+    xml += tag(
+      "p:xfrm",
+      void 0,
+      tag("a:off", { x: inchesToEmu(p.x), y: inchesToEmu(p.y) }) + tag("a:ext", { cx: inchesToEmu(p.w), cy: inchesToEmu(p.h) })
+    );
+    xml += openTag("a:graphic");
+    xml += openTag("a:graphicData", {
+      uri: "http://schemas.openxmlformats.org/drawingml/2006/table"
+    });
+    xml += openTag("a:tbl");
+    const tblPrAttrs = {
+      firstRow: element.firstRow ? "1" : "0",
+      lastRow: element.lastRow ? "1" : "0",
+      firstCol: element.firstCol ? "1" : "0",
+      lastCol: element.lastCol ? "1" : "0",
+      bandRow: element.bandRow ? "1" : "0",
+      bandCol: element.bandCol ? "1" : "0"
+    };
+    let tblPrChildren = "";
+    if (element.fill) {
+      tblPrChildren += serializeFill(element.fill, ctx);
+    }
+    if (element.border) {
+      tblPrChildren += serializeTableBorders(element.border);
+    }
+    if (element.tableStyleId) {
+      tblPrChildren += tag("a:tblStyle", { val: element.tableStyleId });
+    }
+    xml += tag("a:tblPr", tblPrAttrs, tblPrChildren || void 0);
+    xml += openTag("a:tblGrid");
+    const defaultColWidth = p.w / numCols;
+    for (let i = 0; i < numCols; i++) {
+      const w = element.colWidths?.[i] ?? defaultColWidth;
+      xml += tag("a:gridCol", { w: inchesToEmu(w) });
+    }
+    xml += closeTag("a:tblGrid");
+    const defaultRowHeight = p.h / element.rows.length;
+    for (let r = 0; r < element.rows.length; r++) {
+      const h = element.rowHeights?.[r] ?? defaultRowHeight;
+      xml += openTag("a:tr", { h: inchesToEmu(h) });
+      for (const cell of element.rows[r]) {
+        xml += serializeCell(cell, element.border, ctx);
+      }
+      xml += closeTag("a:tr");
+    }
+    xml += closeTag("a:tbl");
+    xml += closeTag("a:graphicData");
+    xml += closeTag("a:graphic");
+    xml += closeTag("p:graphicFrame");
+    return xml;
+  }
+};
+
+// src/ooxml/serializers/chart.ts
+function serializeTrendline(t) {
+  let xml = openTag("c:trendline");
+  xml += tag("c:trendlineType", { val: t.type ?? "linear" });
+  if (t.order !== void 0) xml += tag("c:order", { val: t.order });
+  if (t.period !== void 0) xml += tag("c:period", { val: t.period });
+  if (t.forward !== void 0) xml += tag("c:forward", { val: t.forward });
+  if (t.backward !== void 0) xml += tag("c:backward", { val: t.backward });
+  if (t.intercept !== void 0) xml += tag("c:intercept", { val: t.intercept });
+  if (t.displayEquation) xml += tag("c:dispEq", { val: "1" });
+  if (t.displayRSquared) xml += tag("c:dispRSqr", { val: "1" });
+  if (t.color || t.width || t.dash) {
+    let spPr = "";
+    const lnAttrs = {};
+    if (t.width) lnAttrs.w = ptToEmu(t.width);
+    let lnChildren = "";
+    if (t.color) lnChildren += serializeSolidFill(t.color);
+    if (t.dash && t.dash !== "solid") lnChildren += tag("a:prstDash", { val: t.dash });
+    spPr += tag(
+      "a:ln",
+      Object.keys(lnAttrs).length > 0 ? lnAttrs : void 0,
+      lnChildren || void 0
+    );
+    xml += tag("c:spPr", void 0, spPr);
+  }
+  xml += closeTag("c:trendline");
+  return xml;
+}
+function serializeErrorBars(e) {
+  let xml = openTag("c:errBars");
+  xml += tag("c:errDir", { val: e.direction ?? "y" });
+  xml += tag("c:errBarType", { val: e.type ?? "both" });
+  xml += tag("c:errValType", { val: e.valueType ?? "fixedVal" });
+  if (e.noEndCap) xml += tag("c:noEndCap", { val: "1" });
+  if (e.value !== void 0) xml += tag("c:val", { val: e.value });
+  if (e.color || e.width) {
+    let spPr = "";
+    const lnAttrs = {};
+    if (e.width) lnAttrs.w = ptToEmu(e.width);
+    let lnChildren = "";
+    if (e.color) lnChildren += serializeSolidFill(e.color);
+    spPr += tag(
+      "a:ln",
+      Object.keys(lnAttrs).length > 0 ? lnAttrs : void 0,
+      lnChildren || void 0
+    );
+    xml += tag("c:spPr", void 0, spPr);
+  }
+  xml += closeTag("c:errBars");
+  return xml;
+}
+function serializeDataLabels(dl) {
+  let xml = openTag("c:dLbls");
+  if (dl.position) xml += tag("c:dLblPos", { val: dl.position });
+  if (dl.numberFormat) {
+    xml += tag("c:numFmt", { formatCode: dl.numberFormat, sourceLinked: "0" });
+  }
+  if (dl.fontSize || dl.fontFace || dl.color) {
+    let rPrChildren = "";
+    if (dl.color) rPrChildren += serializeSolidFill(dl.color);
+    if (dl.fontFace) rPrChildren += tag("a:latin", { typeface: dl.fontFace });
+    const rPrAttrs = {};
+    if (dl.fontSize) rPrAttrs.sz = ptToHundredths(dl.fontSize);
+    xml += tag(
+      "c:txPr",
+      void 0,
+      tag("a:bodyPr") + tag("a:lstStyle") + tag(
+        "a:p",
+        void 0,
+        tag(
+          "a:pPr",
+          void 0,
+          tag(
+            "a:defRPr",
+            Object.keys(rPrAttrs).length > 0 ? rPrAttrs : void 0,
+            rPrChildren || void 0
+          )
+        )
+      )
+    );
+  }
+  if (dl.separator) xml += tag("c:separator", void 0, dl.separator);
+  xml += tag("c:showVal", { val: dl.showValue !== false ? "1" : "0" });
+  xml += tag("c:showCatName", { val: dl.showCategory ? "1" : "0" });
+  xml += tag("c:showSerName", { val: dl.showSeriesName ? "1" : "0" });
+  xml += tag("c:showPercent", { val: dl.showPercent ? "1" : "0" });
+  xml += closeTag("c:dLbls");
+  return xml;
+}
+var chartCounter = 0;
+var CHART_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+var CHART_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+var DEFAULT_COLORS = [
+  "4472C4",
+  "ED7D31",
+  "A5A5A5",
+  "FFC000",
+  "5B9BD5",
+  "70AD47",
+  "264478",
+  "9B57A2",
+  "636363",
+  "EB6B0A"
+];
+function serializeAxis(axisTag, axId, crossAxId, position, opts, showGridLines) {
+  let xml = openTag(axisTag);
+  xml += tag("c:axId", void 0, axId);
+  let scalingChildren = tag("c:orientation", { val: opts?.orientation ?? "minMax" });
+  if (opts?.min !== void 0) scalingChildren += tag("c:min", { val: opts.min });
+  if (opts?.max !== void 0) scalingChildren += tag("c:max", { val: opts.max });
+  if (opts?.logBase !== void 0) scalingChildren += tag("c:logBase", { val: opts.logBase });
+  xml += tag("c:scaling", void 0, scalingChildren);
+  xml += tag("c:delete", { val: opts?.delete ? "1" : "0" });
+  xml += tag("c:axPos", { val: opts?.position ?? position });
+  if (opts?.format) {
+    xml += tag("c:numFmt", { formatCode: opts.format, sourceLinked: "0" });
+  }
+  const showMajor = opts?.majorGridlines ?? (axisTag === "c:valAx" && showGridLines);
+  if (showMajor) {
+    if (typeof showMajor === "object") {
+      const glAttrs = {};
+      if (showMajor.width) glAttrs.w = ptToEmu(showMajor.width);
+      let glChildren = "";
+      if (showMajor.color) {
+        glChildren = serializeSolidFill(showMajor.color);
+      }
+      xml += tag(
+        "c:majorGridlines",
+        void 0,
+        tag("c:spPr", void 0, tag("a:ln", glAttrs, glChildren || void 0))
+      );
+    } else {
+      xml += tag("c:majorGridlines");
+    }
+  }
+  if (opts?.minorGridlines) {
+    if (typeof opts.minorGridlines === "object") {
+      const glAttrs = {};
+      if (opts.minorGridlines.width) glAttrs.w = ptToEmu(opts.minorGridlines.width);
+      let glChildren = "";
+      if (opts.minorGridlines.color) {
+        glChildren = serializeSolidFill(opts.minorGridlines.color);
+      }
+      xml += tag(
+        "c:minorGridlines",
+        void 0,
+        tag("c:spPr", void 0, tag("a:ln", glAttrs, glChildren || void 0))
+      );
+    } else {
+      xml += tag("c:minorGridlines");
+    }
+  }
+  if (opts?.title) {
+    const titleRPrAttrs = { lang: "en-US" };
+    if (opts.titleFontSize) titleRPrAttrs.sz = ptToHundredths(opts.titleFontSize);
+    xml += tag(
+      "c:title",
+      void 0,
+      tag(
+        "c:tx",
+        void 0,
+        tag(
+          "c:rich",
+          void 0,
+          tag("a:bodyPr") + tag("a:lstStyle") + tag(
+            "a:p",
+            void 0,
+            tag("a:pPr", void 0, tag("a:defRPr", titleRPrAttrs)) + tag(
+              "a:r",
+              void 0,
+              tag("a:rPr", titleRPrAttrs) + tag("a:t", void 0, escapeXml(opts.title))
+            )
+          )
+        )
+      ) + tag("c:overlay", { val: "0" })
+    );
+  }
+  if (opts?.majorUnit) xml += tag("c:majorUnit", { val: opts.majorUnit });
+  if (opts?.minorUnit) xml += tag("c:minorUnit", { val: opts.minorUnit });
+  if (opts?.labelFontSize || opts?.labelColor || opts?.labelRotation !== void 0) {
+    const bodyAttrs = {};
+    if (opts?.labelRotation !== void 0) bodyAttrs.rot = Math.round(opts.labelRotation * 6e4);
+    const rPrAttrs = {};
+    if (opts?.labelFontSize) rPrAttrs.sz = ptToHundredths(opts.labelFontSize);
+    let rPrChildren = "";
+    if (opts?.labelColor) rPrChildren = serializeSolidFill(opts.labelColor);
+    xml += tag(
+      "c:txPr",
+      void 0,
+      tag("a:bodyPr", bodyAttrs) + tag("a:lstStyle") + tag(
+        "a:p",
+        void 0,
+        tag("a:pPr", void 0, tag("a:defRPr", rPrAttrs, rPrChildren || void 0))
+      )
+    );
+  }
+  xml += tag("c:crossAx", void 0, crossAxId);
+  if (opts?.crossesAt !== void 0) {
+    if (opts.crossesAt === "min") xml += tag("c:crosses", { val: "min" });
+    else if (opts.crossesAt === "max") xml += tag("c:crosses", { val: "max" });
+    else if (opts.crossesAt === "auto") xml += tag("c:crosses", { val: "autoZero" });
+    else xml += tag("c:crossesAt", { val: opts.crossesAt });
+  }
+  xml += closeTag(axisTag);
+  return xml;
+}
+function serializeSeriesData(data, chartType, showDataLabels) {
+  let xml = "";
+  const isScatter = chartType === "scatter";
+  for (let i = 0; i < data.series.length; i++) {
+    const s = data.series[i];
+    const color = s.color ?? DEFAULT_COLORS[i % DEFAULT_COLORS.length];
+    xml += openTag("c:ser");
+    xml += tag("c:idx", { val: i });
+    xml += tag("c:order", { val: i });
+    xml += tag(
+      "c:tx",
+      void 0,
+      tag(
+        "c:strRef",
+        void 0,
+        tag("c:f", void 0, `Sheet1!$B$1`) + tag(
+          "c:strCache",
+          void 0,
+          tag("c:ptCount", { val: "1" }) + tag("c:pt", { idx: "0" }, tag("c:v", void 0, escapeXml(s.name)))
+        )
+      )
+    );
+    let spPrChildren = serializeSolidFill(color);
+    if (s.lineWidth || s.lineDash) {
+      const lnAttrs = {};
+      if (s.lineWidth) lnAttrs.w = ptToEmu(s.lineWidth);
+      let lnChildren = serializeSolidFill(color);
+      if (s.lineDash && s.lineDash !== "solid") {
+        lnChildren += tag("a:prstDash", { val: s.lineDash });
+      }
+      spPrChildren += tag("a:ln", lnAttrs, lnChildren);
+    }
+    if (s.opacity !== void 0 && s.opacity < 100) {
+      spPrChildren = tag(
+        "a:solidFill",
+        void 0,
+        serializeColorWithAlpha(s.fill ?? color, s.opacity)
+      );
+    }
+    xml += tag("c:spPr", void 0, spPrChildren);
+    if (s.marker) {
+      let markerXml = "";
+      markerXml += tag("c:symbol", { val: s.marker.type ?? "circle" });
+      if (s.marker.size) markerXml += tag("c:size", { val: s.marker.size });
+      let markerSpPr = "";
+      if (s.marker.fill) {
+        markerSpPr += serializeSolidFill(s.marker.fill);
+      }
+      if (s.marker.border) {
+        let lnChildren = "";
+        if (s.marker.border.color) {
+          lnChildren = serializeSolidFill(s.marker.border.color);
+        }
+        const lnAttrs = {};
+        if (s.marker.border.width) lnAttrs.w = ptToEmu(s.marker.border.width);
+        markerSpPr += tag("a:ln", lnAttrs, lnChildren || void 0);
+      }
+      if (markerSpPr) markerXml += tag("c:spPr", void 0, markerSpPr);
+      xml += tag("c:marker", void 0, markerXml);
+    }
+    if (s.colors && s.colors.length > 0) {
+      for (let j = 0; j < s.colors.length; j++) {
+        xml += tag(
+          "c:dPt",
+          void 0,
+          tag("c:idx", { val: j }) + tag("c:spPr", void 0, serializeSolidFill(s.colors[j]))
+        );
+      }
+    }
+    if (showDataLabels) {
+      xml += tag(
+        "c:dLbls",
+        void 0,
+        tag("c:showVal", { val: "1" }) + tag("c:showCatName", { val: "0" }) + tag("c:showSerName", { val: "0" })
+      );
+    } else if (s.dataLabels) {
+      xml += serializeDataLabels(s.dataLabels);
+    }
+    if (s.trendline) {
+      xml += serializeTrendline(s.trendline);
+    }
+    if (s.errorBars) {
+      xml += serializeErrorBars(s.errorBars);
+    }
+    if (s.explosion !== void 0) {
+      xml += tag("c:explosion", { val: s.explosion });
+    }
+    if (s.smooth) {
+      xml += tag("c:smooth", { val: "1" });
+    }
+    if (data.categories && !isScatter) {
+      xml += openTag("c:cat");
+      xml += openTag("c:strRef");
+      xml += tag("c:f", void 0, "Sheet1!$A$2:$A$" + (data.categories.length + 1));
+      xml += openTag("c:strCache");
+      xml += tag("c:ptCount", { val: data.categories.length });
+      for (let j = 0; j < data.categories.length; j++) {
+        xml += tag("c:pt", { idx: j }, tag("c:v", void 0, escapeXml(data.categories[j])));
+      }
+      xml += closeTag("c:strCache");
+      xml += closeTag("c:strRef");
+      xml += closeTag("c:cat");
+    }
+    if (isScatter && data.xValues) {
+      xml += openTag("c:xVal");
+      xml += openTag("c:numRef");
+      xml += tag("c:f", void 0, `Sheet1!$A$2:$A$${data.xValues.length + 1}`);
+      xml += openTag("c:numCache");
+      xml += tag("c:formatCode", void 0, "General");
+      xml += tag("c:ptCount", { val: data.xValues.length });
+      for (let j = 0; j < data.xValues.length; j++) {
+        xml += tag("c:pt", { idx: j }, tag("c:v", void 0, String(data.xValues[j])));
+      }
+      xml += closeTag("c:numCache");
+      xml += closeTag("c:numRef");
+      xml += closeTag("c:xVal");
+      xml += openTag("c:yVal");
+    } else {
+      xml += openTag("c:val");
+    }
+    xml += openTag("c:numRef");
+    xml += tag("c:f", void 0, `Sheet1!$B$2:$B$${s.values.length + 1}`);
+    xml += openTag("c:numCache");
+    xml += tag("c:formatCode", void 0, "General");
+    xml += tag("c:ptCount", { val: s.values.length });
+    for (let j = 0; j < s.values.length; j++) {
+      xml += tag("c:pt", { idx: j }, tag("c:v", void 0, String(s.values[j])));
+    }
+    xml += closeTag("c:numCache");
+    xml += closeTag("c:numRef");
+    xml += closeTag(isScatter ? "c:yVal" : "c:val");
+    if (chartType === "bubble" && data.bubbleSizes) {
+      xml += openTag("c:bubbleSize");
+      xml += openTag("c:numRef");
+      xml += tag("c:f", void 0, `Sheet1!$C$2:$C$${data.bubbleSizes.length + 1}`);
+      xml += openTag("c:numCache");
+      xml += tag("c:formatCode", void 0, "General");
+      xml += tag("c:ptCount", { val: data.bubbleSizes.length });
+      for (let j = 0; j < data.bubbleSizes.length; j++) {
+        xml += tag("c:pt", { idx: j }, tag("c:v", void 0, String(data.bubbleSizes[j])));
+      }
+      xml += closeTag("c:numCache");
+      xml += closeTag("c:numRef");
+      xml += closeTag("c:bubbleSize");
+    }
+    xml += closeTag("c:ser");
+  }
+  return xml;
+}
+function getOoxmlChartTag(chartType) {
+  const map = {
+    bar: "c:barChart",
+    col: "c:barChart",
+    line: "c:lineChart",
+    pie: "c:pieChart",
+    area: "c:areaChart",
+    scatter: "c:scatterChart",
+    doughnut: "c:doughnutChart",
+    radar: "c:radarChart",
+    bubble: "c:bubbleChart",
+    stock: "c:stockChart",
+    surface: "c:surfaceChart",
+    bar3D: "c:bar3DChart",
+    col3D: "c:bar3DChart",
+    line3D: "c:line3DChart",
+    pie3D: "c:pie3DChart",
+    area3D: "c:area3DChart"
+  };
+  return map[chartType];
+}
+function serializeChartXml(element) {
+  const { chartType, data, title, showLegend, showDataLabels, showGridLines } = element;
+  const chartTag = getOoxmlChartTag(chartType);
+  const noAxesTypes = ["pie", "doughnut", "pie3D"];
+  const hasAxes = !noAxesTypes.includes(chartType);
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("c:chartSpace", {
+    "xmlns:c": CHART_NS,
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r
+  });
+  xml += openTag("c:chart");
+  if (title) {
+    const titleRPrAttrs = { lang: "en-US" };
+    if (element.titleFontSize) titleRPrAttrs.sz = ptToHundredths(element.titleFontSize);
+    let titleRPrChildren = "";
+    if (element.titleColor) {
+      titleRPrChildren = serializeSolidFill(element.titleColor);
+    }
+    xml += tag(
+      "c:title",
+      void 0,
+      tag(
+        "c:tx",
+        void 0,
+        tag(
+          "c:rich",
+          void 0,
+          tag("a:bodyPr") + tag("a:lstStyle") + tag(
+            "a:p",
+            void 0,
+            tag(
+              "a:pPr",
+              void 0,
+              tag("a:defRPr", titleRPrAttrs, titleRPrChildren || void 0)
+            ) + tag(
+              "a:r",
+              void 0,
+              tag("a:rPr", titleRPrAttrs, titleRPrChildren || void 0) + tag("a:t", void 0, escapeXml(title))
+            )
+          )
+        )
+      ) + tag("c:overlay", { val: "0" })
+    );
+  } else {
+    xml += tag("c:autoTitleDeleted", { val: "1" });
+  }
+  if (element.view3D) {
+    let v3d = "";
+    if (element.view3D.rotX !== void 0) v3d += tag("c:rotX", { val: element.view3D.rotX });
+    if (element.view3D.rotY !== void 0) v3d += tag("c:rotY", { val: element.view3D.rotY });
+    if (element.view3D.depthPercent !== void 0)
+      v3d += tag("c:depthPercent", { val: element.view3D.depthPercent });
+    if (element.view3D.rAngAx !== void 0)
+      v3d += tag("c:rAngAx", { val: element.view3D.rAngAx ? "1" : "0" });
+    if (element.view3D.perspective !== void 0)
+      v3d += tag("c:perspective", { val: element.view3D.perspective });
+    xml += tag("c:view3D", void 0, v3d);
+  }
+  xml += openTag("c:plotArea");
+  xml += tag("c:layout");
+  xml += openTag(chartTag);
+  if (chartType === "bar" || chartType === "bar3D") {
+    xml += tag("c:barDir", { val: "bar" });
+    xml += tag("c:grouping", { val: element.barGrouping ?? "clustered" });
+  } else if (chartType === "col" || chartType === "col3D") {
+    xml += tag("c:barDir", { val: "col" });
+    xml += tag("c:grouping", { val: element.barGrouping ?? "clustered" });
+  } else if (chartType === "line" || chartType === "line3D") {
+    xml += tag("c:grouping", { val: element.lineGrouping ?? "standard" });
+  } else if (chartType === "area" || chartType === "area3D") {
+    xml += tag("c:grouping", { val: element.areaGrouping ?? "standard" });
+  } else if (chartType === "scatter") {
+    xml += tag("c:scatterStyle", { val: element.scatterStyle ?? "lineMarker" });
+  } else if (chartType === "radar") {
+    xml += tag("c:radarStyle", { val: element.radarStyle ?? "marker" });
+  }
+  xml += serializeSeriesData(data, chartType, showDataLabels);
+  if (chartType === "pie" || chartType === "pie3D") {
+    if (element.pieExplosion) {
+      for (let i = 0; i < data.series[0]?.values.length; i++) {
+        xml += tag(
+          "c:dPt",
+          void 0,
+          tag("c:idx", { val: i }) + tag("c:explosion", { val: element.pieExplosion })
+        );
+      }
+    }
+  }
+  if (chartType === "doughnut") {
+    xml += tag("c:holeSize", { val: element.doughnutHoleSize ?? 50 });
+  }
+  if ((chartType === "bar" || chartType === "col" || chartType === "bar3D" || chartType === "col3D") && element.barGapWidth !== void 0) {
+    xml += tag("c:gapWidth", { val: element.barGapWidth });
+  }
+  if ((chartType === "bar" || chartType === "col" || chartType === "bar3D" || chartType === "col3D") && element.barOverlap !== void 0) {
+    xml += tag("c:overlap", { val: element.barOverlap });
+  }
+  if (hasAxes) {
+    xml += tag("c:axId", { val: "1" });
+    xml += tag("c:axId", { val: "2" });
+  }
+  xml += closeTag(chartTag);
+  if (hasAxes) {
+    xml += serializeAxis("c:catAx", "1", "2", "b", element.catAxis, showGridLines);
+    xml += serializeAxis("c:valAx", "2", "1", "l", element.valAxis, showGridLines);
+    if (element.secondaryValAxis) {
+      xml += serializeAxis("c:valAx", "3", "1", "r", element.secondaryValAxis, false);
+    }
+  }
+  if (element.plotArea) {
+    let plotSpPr = "";
+    if (element.plotArea.fill) {
+      plotSpPr += serializeSolidFill(element.plotArea.fill);
+    }
+    if (plotSpPr) {
+      xml += tag("c:spPr", void 0, plotSpPr);
+    }
+  }
+  xml += closeTag("c:plotArea");
+  if (showLegend) {
+    xml += tag(
+      "c:legend",
+      void 0,
+      tag("c:legendPos", { val: element.legendPosition ?? "b" }) + tag("c:overlay", { val: "0" })
+    );
+  }
+  xml += tag("c:plotVisOnly", { val: "1" });
+  xml += closeTag("c:chart");
+  if (element.fill) {
+    xml += tag("c:spPr", void 0, serializeSolidFill(element.fill));
+  }
+  xml += closeTag("c:chartSpace");
+  return xml;
+}
+var chartSerializer = {
+  type: "chart",
+  serialize(element, ctx) {
+    chartCounter++;
+    const chartFileName = `chart${chartCounter}.xml`;
+    const target = `../charts/${chartFileName}`;
+    const chartXml = serializeChartXml(element);
+    const encoder2 = new TextEncoder();
+    const rId = ctx.addRelationship(CHART_REL_TYPE, target, encoder2.encode(chartXml));
+    const p = element.placement;
+    let xml = openTag("p:graphicFrame");
+    xml += tag(
+      "p:nvGraphicFramePr",
+      void 0,
+      tag("p:cNvPr", { id: "0", name: element.name ?? "Chart" }) + tag("p:cNvGraphicFramePr") + tag("p:nvPr")
+    );
+    xml += tag(
+      "p:xfrm",
+      void 0,
+      tag("a:off", { x: inchesToEmu(p.x), y: inchesToEmu(p.y) }) + tag("a:ext", { cx: inchesToEmu(p.w), cy: inchesToEmu(p.h) })
+    );
+    xml += tag(
+      "a:graphic",
+      void 0,
+      tag("a:graphicData", { uri: CHART_NS }, tag("c:chart", { "xmlns:c": CHART_NS, "r:id": rId }))
+    );
+    xml += closeTag("p:graphicFrame");
+    return xml;
+  }
+};
+
+// src/ooxml/serializers/media.ts
+import { readFileSync as readFileSync3 } from "fs";
+var mediaCounter = 0;
+var MEDIA_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/video";
+var AUDIO_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio";
+function extFromContentType(ct) {
+  const map = {
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "video/avi": "avi",
+    "audio/mpeg": "mp3",
+    "audio/mp3": "mp3",
+    "audio/wav": "wav",
+    "audio/ogg": "ogg"
+  };
+  return map[ct] ?? ct.split("/")[1] ?? "bin";
+}
+var mediaSerializer = {
+  type: "media",
+  serialize(element, ctx) {
+    mediaCounter++;
+    const ext = extFromContentType(element.contentType);
+    const fileName = `media${mediaCounter}.${ext}`;
+    const target = `../media/${fileName}`;
+    const relType = element.mediaType === "audio" ? AUDIO_REL_TYPE : MEDIA_REL_TYPE;
+    let data = element.data;
+    if (!data && element.path) {
+      data = readFileSync3(element.path);
+    }
+    if (!data) throw new Error("Media element must have data or path");
+    const rId = ctx.addRelationship(relType, target, data);
+    const p = element.placement;
+    if (element.mediaType === "audio") {
+      let xml2 = openTag("p:sp");
+      xml2 += tag(
+        "p:nvSpPr",
+        void 0,
+        tag("p:cNvPr", { id: "0", name: element.name ?? "Audio" }) + tag("p:cNvSpPr") + tag("p:nvPr", void 0, tag("a:audioFile", { "r:link": rId }))
+      );
+      xml2 += openTag("p:spPr");
+      xml2 += serializeTransform(p, element.transform);
+      xml2 += tag("a:prstGeom", { prst: "rect" }, tag("a:avLst"));
+      if (element.effects) xml2 += serializeEffects(element.effects);
+      xml2 += closeTag("p:spPr");
+      xml2 += closeTag("p:sp");
+      return xml2;
+    }
+    let posterRId;
+    if (element.poster) {
+      let posterData = element.poster.data;
+      if (!posterData && element.poster.path) {
+        posterData = readFileSync3(element.poster.path);
+      }
+      if (posterData) {
+        const pCt = element.poster.contentType ?? "image/png";
+        const pExt = pCt.split("/")[1] ?? "png";
+        const posterFile = `poster${mediaCounter}.${pExt}`;
+        posterRId = ctx.addRelationship(REL_TYPE.image, `../media/${posterFile}`, posterData);
+      }
+    }
+    let xml = openTag("p:pic");
+    xml += tag(
+      "p:nvPicPr",
+      void 0,
+      tag("p:cNvPr", { id: "0", name: element.name ?? "Video" }) + tag("p:cNvPicPr", void 0, tag("a:picLocks", { noChangeAspect: "1" })) + tag("p:nvPr", void 0, tag("a:videoFile", { "r:link": rId }))
+    );
+    xml += tag(
+      "p:blipFill",
+      void 0,
+      tag("a:blip", posterRId ? { "r:embed": posterRId } : void 0) + tag("a:stretch", void 0, tag("a:fillRect"))
+    );
+    xml += openTag("p:spPr");
+    xml += serializeTransform(p, element.transform);
+    xml += tag("a:prstGeom", { prst: "rect" }, tag("a:avLst"));
+    if (element.effects) xml += serializeEffects(element.effects);
+    xml += closeTag("p:spPr");
+    xml += closeTag("p:pic");
+    return xml;
+  }
+};
+
+// src/ooxml/serializers/group.ts
+function createGroupSerializer(registry) {
+  return {
+    type: "group",
+    serialize(element, ctx) {
+      const p = element.placement;
+      let xml = openTag("p:grpSp");
+      xml += tag(
+        "p:nvGrpSpPr",
+        void 0,
+        tag("p:cNvPr", { id: "0", name: element.name ?? "" }) + tag("p:cNvGrpSpPr") + tag("p:nvPr")
+      );
+      xml += tag(
+        "p:grpSpPr",
+        void 0,
+        tag(
+          "a:xfrm",
+          void 0,
+          tag("a:off", { x: inchesToEmu(p.x), y: inchesToEmu(p.y) }) + tag("a:ext", { cx: inchesToEmu(p.w), cy: inchesToEmu(p.h) }) + tag("a:chOff", { x: inchesToEmu(p.x), y: inchesToEmu(p.y) }) + tag("a:chExt", { cx: inchesToEmu(p.w), cy: inchesToEmu(p.h) })
+        )
+      );
+      for (const child of element.children) {
+        const serializer = registry.getSerializer(child.type);
+        if (serializer) {
+          xml += serializer.serialize(child, ctx);
+        }
+      }
+      xml += closeTag("p:grpSp");
+      return xml;
+    }
+  };
+}
+
+// src/ooxml/serializers/connector.ts
+var CONNECTOR_GEOM = {
+  straight: "straightConnector1",
+  elbow: "bentConnector3",
+  curved: "curvedConnector3"
+};
+var connectorSerializer = {
+  type: "connector",
+  serialize(element, _ctx) {
+    const p = element.placement;
+    const prst = CONNECTOR_GEOM[element.connectorType] ?? "straightConnector1";
+    let xml = openTag("p:cxnSp");
+    xml += tag(
+      "p:nvCxnSpPr",
+      void 0,
+      tag("p:cNvPr", { id: "0", name: element.name ?? "" }) + tag("p:cNvCxnSpPr") + tag("p:nvPr")
+    );
+    xml += openTag("p:spPr");
+    xml += serializeTransform(p);
+    xml += tag("a:prstGeom", { prst }, tag("a:avLst"));
+    if (element.line) {
+      xml += serializeLine(element.line);
+    } else {
+      let defaultLn = serializeSolidFill("000000");
+      if (element.startArrow) {
+        const hAttrs = {};
+        if (element.startArrow.type) hAttrs.type = element.startArrow.type;
+        if (element.startArrow.width) hAttrs.w = element.startArrow.width;
+        if (element.startArrow.length) hAttrs.len = element.startArrow.length;
+        defaultLn += tag("a:headEnd", hAttrs);
+      }
+      if (element.endArrow) {
+        const tAttrs = {};
+        if (element.endArrow.type) tAttrs.type = element.endArrow.type;
+        if (element.endArrow.width) tAttrs.w = element.endArrow.width;
+        if (element.endArrow.length) tAttrs.len = element.endArrow.length;
+        defaultLn += tag("a:tailEnd", tAttrs);
+      }
+      xml += tag("a:ln", { w: "12700" }, defaultLn);
+    }
+    xml += closeTag("p:spPr");
+    xml += closeTag("p:cxnSp");
+    return xml;
+  }
+};
+
+// src/io/writer.ts
+import { zipSync } from "fflate";
+
+// src/core/relationships.ts
+var RelationshipManager = class {
+  counter = 0;
+  rels = [];
+  add(type, target, data, external) {
+    this.counter++;
+    const id = `rId${this.counter}`;
+    this.rels.push({ id, type, target, data, external });
+    return id;
+  }
+  getAll() {
+    return this.rels;
+  }
+  toXml() {
+    let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+    xml += '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">';
+    for (const rel of this.rels) {
+      const attrs = {
+        Id: rel.id,
+        Type: rel.type,
+        Target: rel.target
+      };
+      if (rel.external) {
+        attrs.TargetMode = "External";
+      }
+      xml += tag("Relationship", attrs);
+    }
+    xml += "</Relationships>";
+    return xml;
+  }
+};
+
+// src/ooxml/serializers/slide.ts
+function serializeTransition(t) {
+  const attrs = {};
+  if (t.durationMs !== void 0) {
+    attrs.dur = t.durationMs;
+  } else if (t.duration) {
+    attrs.spd = t.duration <= 500 ? "fast" : t.duration <= 1500 ? "med" : "slow";
+  }
+  if (t.advanceOnClick === false) attrs.advClick = "0";
+  if (t.advanceAfter !== void 0) {
+    attrs.advTm = t.advanceAfter;
+  }
+  const type = t.type ?? "fade";
+  let child = "";
+  const transMap = {
+    fade: "p:fade",
+    push: "p:push",
+    wipe: "p:wipe",
+    split: "p:split",
+    cover: "p:cover",
+    uncover: "p:uncover",
+    strips: "p:strips",
+    blinds: "p:blinds",
+    checker: "p:checker",
+    dissolve: "p:dissolve",
+    comb: "p:comb",
+    newsflash: "p:newsflash",
+    randomBars: "p:randomBar",
+    circle: "p:circle",
+    diamond: "p:diamond",
+    plus: "p:plus",
+    wedge: "p:wedge",
+    wheel: "p:wheel",
+    zoom: "p:zoom",
+    cut: "p:cut",
+    random: "p:random"
+  };
+  const elName = transMap[type];
+  if (elName && type !== "none") {
+    const dirAttrs = {};
+    if (t.direction) dirAttrs.dir = t.direction;
+    child = tag(elName, Object.keys(dirAttrs).length > 0 ? dirAttrs : void 0);
+  }
+  return tag("p:transition", attrs, child || void 0);
+}
+function serializeAnimations(animations) {
+  let tnLstXml = "";
+  for (let i = 0; i < animations.length; i++) {
+    const anim = animations[i];
+    const dur = anim.duration ?? 500;
+    const delay = anim.delay ?? 0;
+    const spTgtId = String(anim.elementIndex + 2);
+    let nodeType;
+    if (anim.trigger === "withPrevious") nodeType = "withEffect";
+    else if (anim.trigger === "afterPrevious") nodeType = "afterEffect";
+    else nodeType = "clickEffect";
+    const cTnAttrs = {
+      id: String((i + 1) * 10 + 1),
+      dur: String(dur),
+      fill: "hold"
+    };
+    if (anim.acceleration !== void 0) cTnAttrs.accel = Math.round(anim.acceleration * 1e3);
+    if (anim.deceleration !== void 0) cTnAttrs.decel = Math.round(anim.deceleration * 1e3);
+    const tgtEl = tag("p:tgtEl", void 0, tag("p:spTgt", { spid: spTgtId }));
+    const stCond = tag("p:stCondLst", void 0, tag("p:cond", { delay: String(delay) }));
+    let animEffect;
+    if (anim.motionPath) {
+      animEffect = tag(
+        "p:animMotion",
+        { origin: "layout", path: anim.motionPath, pathEditMode: "relative" },
+        tag("p:cBhvr", void 0, tag("p:cTn", cTnAttrs, stCond) + tgtEl)
+      );
+    } else if (anim.effect === "appear") {
+      const setCTn = { ...cTnAttrs, dur: "1" };
+      animEffect = tag(
+        "p:set",
+        void 0,
+        tag("p:cBhvr", void 0, tag("p:cTn", setCTn, stCond) + tgtEl) + tag("p:to", void 0, tag("p:strVal", { val: "visible" }))
+      );
+    } else {
+      animEffect = tag(
+        "p:animEffect",
+        { transition: anim.category === "exit" ? "out" : "in", filter: anim.effect },
+        tag("p:cBhvr", void 0, tag("p:cTn", cTnAttrs, stCond) + tgtEl)
+      );
+    }
+    const childTnXml = tag(
+      "p:par",
+      void 0,
+      tag(
+        "p:cTn",
+        { id: String((i + 1) * 10), fill: "hold", nodeType },
+        tag("p:stCondLst", void 0, tag("p:cond", { delay: "0" })) + tag("p:childTnLst", void 0, animEffect)
+      )
+    );
+    tnLstXml += childTnXml;
+  }
+  const mainSeq = tag(
+    "p:seq",
+    { concurrent: "1", nextAc: "seek" },
+    tag(
+      "p:cTn",
+      { id: "1", dur: "indefinite", nodeType: "mainSeq" },
+      tag("p:childTnLst", void 0, tnLstXml)
+    ) + tag(
+      "p:prevCondLst",
+      void 0,
+      tag("p:cond", { evt: "onPrev", delay: "0" }, tag("p:tgtEl", void 0, tag("p:sldTgt")))
+    ) + tag(
+      "p:nextCondLst",
+      void 0,
+      tag("p:cond", { evt: "onNext", delay: "0" }, tag("p:tgtEl", void 0, tag("p:sldTgt")))
+    )
+  );
+  return tag("p:timing", void 0, tag("p:tnLst", void 0, mainSeq));
+}
+function serializeSlide(elements, slideIndex, theme, registry, _layoutRId, transition, animations, background) {
+  const relManager = new RelationshipManager();
+  const media = /* @__PURE__ */ new Map();
+  const mediaRels = [];
+  relManager.add(
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout",
+    "../slideLayouts/slideLayout1.xml"
+  );
+  const ctx = {
+    addRelationship(type, target, data) {
+      const rId = relManager.add(type, target);
+      mediaRels.push({ type, target });
+      if (data) {
+        const fileName = target.split("/").pop() ?? "file";
+        if (target.includes("/charts/")) {
+          media.set(`ppt/charts/${fileName}`, data);
+        } else {
+          media.set(`ppt/media/${fileName}`, data);
+        }
+      }
+      return rId;
+    },
+    theme,
+    slideIndex
+  };
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:sld", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  });
+  xml += openTag("p:cSld");
+  if (background) {
+    let bgXml = "";
+    if (background.color) {
+      bgXml = tag("p:bgPr", void 0, serializeSolidFill(background.color) + tag("a:effectLst"));
+    } else if (background.fill) {
+      bgXml = tag("p:bgPr", void 0, serializeFill(background.fill, ctx) + tag("a:effectLst"));
+    }
+    if (bgXml) xml += tag("p:bg", void 0, bgXml);
+  }
+  xml += openTag("p:spTree");
+  xml += tag(
+    "p:nvGrpSpPr",
+    void 0,
+    tag("p:cNvPr", { id: "1", name: "" }) + tag("p:cNvGrpSpPr") + tag("p:nvPr")
+  );
+  xml += tag(
+    "p:grpSpPr",
+    void 0,
+    tag(
+      "a:xfrm",
+      void 0,
+      tag("a:off", { x: "0", y: "0" }) + tag("a:ext", { cx: "0", cy: "0" }) + tag("a:chOff", { x: "0", y: "0" }) + tag("a:chExt", { cx: "0", cy: "0" })
+    )
+  );
+  for (const el of elements) {
+    const serializer = registry.getSerializer(el.type);
+    if (!serializer) {
+      throw new Error(`No serializer registered for element type: ${el.type}`);
+    }
+    xml += serializer.serialize(el, ctx);
+  }
+  xml += closeTag("p:spTree");
+  xml += closeTag("p:cSld");
+  if (transition) {
+    xml += serializeTransition(transition);
+  }
+  if (animations && animations.length > 0) {
+    xml += serializeAnimations(animations);
+  }
+  xml += closeTag("p:sld");
+  return {
+    slideXml: xml,
+    relsXml: relManager.toXml(),
+    media,
+    mediaRels
+  };
+}
+
+// src/ooxml/serializers/presentation.ts
+function serializePresentation(slideCount, slideRIds, slideSize) {
+  const sldW = slideSize?.width ?? DEFAULT_SLIDE_WIDTH;
+  const sldH = slideSize?.height ?? DEFAULT_SLIDE_HEIGHT;
+  const sldType = slideSize?.type ?? "custom";
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:presentation", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p,
+    saveSubsetFonts: "1"
+  });
+  xml += tag(
+    "p:sldMasterIdLst",
+    void 0,
+    tag("p:sldMasterId", { id: "2147483648", "r:id": "rId1" })
+  );
+  xml += openTag("p:sldIdLst");
+  for (let i = 0; i < slideCount; i++) {
+    xml += tag("p:sldId", { id: String(256 + i), "r:id": slideRIds[i] });
+  }
+  xml += closeTag("p:sldIdLst");
+  xml += tag("p:sldSz", {
+    cx: inchesToEmu(sldW),
+    cy: inchesToEmu(sldH),
+    type: sldType
+  });
+  xml += tag("p:notesSz", {
+    cx: inchesToEmu(sldW),
+    cy: inchesToEmu(sldH)
+  });
+  xml += closeTag("p:presentation");
+  return xml;
+}
+
+// src/ooxml/serializers/theme.ts
+function serializeTheme(theme) {
+  const c = theme.colors;
+  const f = theme.fonts;
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("a:theme", {
+    "xmlns:a": NAMESPACE.a,
+    name: theme.name
+  });
+  xml += openTag("a:themeElements");
+  xml += openTag("a:clrScheme", { name: theme.name });
+  const colorEntries = [
+    ["a:dk1", c.dk1],
+    ["a:lt1", c.lt1],
+    ["a:dk2", c.dk2],
+    ["a:lt2", c.lt2],
+    ["a:accent1", c.accent1],
+    ["a:accent2", c.accent2],
+    ["a:accent3", c.accent3],
+    ["a:accent4", c.accent4],
+    ["a:accent5", c.accent5],
+    ["a:accent6", c.accent6],
+    ["a:hlink", c.hlink],
+    ["a:folHlink", c.folHlink]
+  ];
+  for (const [tagName, val] of colorEntries) {
+    xml += tag(tagName, void 0, serializeColor(val));
+  }
+  xml += closeTag("a:clrScheme");
+  xml += openTag("a:fontScheme", { name: theme.name });
+  xml += tag(
+    "a:majorFont",
+    void 0,
+    tag("a:latin", { typeface: f.majorFont }) + tag("a:ea", { typeface: f.majorEastAsian ?? "" }) + tag("a:cs", { typeface: f.majorComplexScript ?? "" })
+  );
+  xml += tag(
+    "a:minorFont",
+    void 0,
+    tag("a:latin", { typeface: f.minorFont }) + tag("a:ea", { typeface: f.minorEastAsian ?? "" }) + tag("a:cs", { typeface: f.minorComplexScript ?? "" })
+  );
+  xml += closeTag("a:fontScheme");
+  xml += openTag("a:fmtScheme", { name: theme.name });
+  xml += tag(
+    "a:fillStyleLst",
+    void 0,
+    tag("a:solidFill", void 0, tag("a:schemeClr", { val: "phClr" })) + tag("a:solidFill", void 0, tag("a:schemeClr", { val: "phClr" })) + tag("a:solidFill", void 0, tag("a:schemeClr", { val: "phClr" }))
+  );
+  xml += tag(
+    "a:lnStyleLst",
+    void 0,
+    tag(
+      "a:ln",
+      { w: "6350", cap: "flat", cmpd: "sng", algn: "ctr" },
+      tag("a:solidFill", void 0, tag("a:schemeClr", { val: "phClr" }))
+    ) + tag(
+      "a:ln",
+      { w: "12700", cap: "flat", cmpd: "sng", algn: "ctr" },
+      tag("a:solidFill", void 0, tag("a:schemeClr", { val: "phClr" }))
+    ) + tag(
+      "a:ln",
+      { w: "19050", cap: "flat", cmpd: "sng", algn: "ctr" },
+      tag("a:solidFill", void 0, tag("a:schemeClr", { val: "phClr" }))
+    )
+  );
+  xml += tag(
+    "a:effectStyleLst",
+    void 0,
+    tag("a:effectStyle", void 0, tag("a:effectLst")) + tag("a:effectStyle", void 0, tag("a:effectLst")) + tag("a:effectStyle", void 0, tag("a:effectLst"))
+  );
+  xml += tag(
+    "a:bgFillStyleLst",
+    void 0,
+    tag("a:solidFill", void 0, tag("a:schemeClr", { val: "phClr" })) + tag("a:solidFill", void 0, tag("a:schemeClr", { val: "phClr" })) + tag("a:solidFill", void 0, tag("a:schemeClr", { val: "phClr" }))
+  );
+  xml += closeTag("a:fmtScheme");
+  xml += closeTag("a:themeElements");
+  xml += tag("a:objectDefaults");
+  if (theme.extraColorSchemes && theme.extraColorSchemes.length > 0) {
+    let extraXml = "";
+    for (let i = 0; i < theme.extraColorSchemes.length; i++) {
+      const ec = theme.extraColorSchemes[i];
+      let schemeXml = "";
+      const extraEntries = [
+        ["a:dk1", ec.dk1],
+        ["a:lt1", ec.lt1],
+        ["a:dk2", ec.dk2],
+        ["a:lt2", ec.lt2],
+        ["a:accent1", ec.accent1],
+        ["a:accent2", ec.accent2],
+        ["a:accent3", ec.accent3],
+        ["a:accent4", ec.accent4],
+        ["a:accent5", ec.accent5],
+        ["a:accent6", ec.accent6],
+        ["a:hlink", ec.hlink],
+        ["a:folHlink", ec.folHlink]
+      ];
+      for (const [tagName, val] of extraEntries) {
+        schemeXml += tag(tagName, void 0, serializeColor(val));
+      }
+      extraXml += tag(
+        "a:extraClrScheme",
+        void 0,
+        tag("a:clrScheme", { name: `Extra ${i + 1}` }, schemeXml)
+      );
+    }
+    xml += tag("a:extraClrSchemeLst", void 0, extraXml);
+  } else {
+    xml += tag("a:extraClrSchemeLst");
+  }
+  xml += closeTag("a:theme");
+  return xml;
+}
+
+// src/ooxml/serializers/slide-master.ts
+function serializeSlideMaster(master, layoutCount) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:sldMaster", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  });
+  xml += openTag("p:cSld");
+  if (master.background) {
+    xml += tag(
+      "p:bg",
+      void 0,
+      tag("p:bgPr", void 0, serializeSolidFill(master.background) + tag("a:effectLst"))
+    );
+  } else {
+    xml += tag(
+      "p:bg",
+      void 0,
+      tag("p:bgRef", { idx: "1001" }, tag("a:schemeClr", { val: "bg1" }))
+    );
+  }
+  xml += openTag("p:spTree");
+  xml += tag(
+    "p:nvGrpSpPr",
+    void 0,
+    tag("p:cNvPr", { id: "1", name: "" }) + tag("p:cNvGrpSpPr") + tag("p:nvPr")
+  );
+  xml += tag(
+    "p:grpSpPr",
+    void 0,
+    tag(
+      "a:xfrm",
+      void 0,
+      tag("a:off", { x: "0", y: "0" }) + tag("a:ext", { cx: "0", cy: "0" }) + tag("a:chOff", { x: "0", y: "0" }) + tag("a:chExt", { cx: "0", cy: "0" })
+    )
+  );
+  xml += closeTag("p:spTree");
+  xml += closeTag("p:cSld");
+  xml += openTag("p:clrMap", {
+    bg1: "lt1",
+    tx1: "dk1",
+    bg2: "lt2",
+    tx2: "dk2",
+    accent1: "accent1",
+    accent2: "accent2",
+    accent3: "accent3",
+    accent4: "accent4",
+    accent5: "accent5",
+    accent6: "accent6",
+    hlink: "hlink",
+    folHlink: "folHlink"
+  });
+  xml += closeTag("p:clrMap");
+  xml += openTag("p:sldLayoutIdLst");
+  for (let i = 0; i < layoutCount; i++) {
+    xml += tag("p:sldLayoutId", { id: String(2147483649 + i), "r:id": `rId${i + 1}` });
+  }
+  xml += closeTag("p:sldLayoutIdLst");
+  xml += closeTag("p:sldMaster");
+  return xml;
+}
+
+// src/ooxml/serializers/slide-layout.ts
+function serializeSlideLayout(layout) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:sldLayout", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p,
+    type: layout.type === "title" ? "title" : layout.type === "blank" ? "blank" : "obj",
+    preserve: "1"
+  });
+  xml += openTag("p:cSld", { name: layout.name });
+  xml += openTag("p:spTree");
+  xml += tag(
+    "p:nvGrpSpPr",
+    void 0,
+    tag("p:cNvPr", { id: "1", name: "" }) + tag("p:cNvGrpSpPr") + tag("p:nvPr")
+  );
+  xml += tag(
+    "p:grpSpPr",
+    void 0,
+    tag(
+      "a:xfrm",
+      void 0,
+      tag("a:off", { x: "0", y: "0" }) + tag("a:ext", { cx: "0", cy: "0" }) + tag("a:chOff", { x: "0", y: "0" }) + tag("a:chExt", { cx: "0", cy: "0" })
+    )
+  );
+  let spId = 2;
+  for (const ph of layout.placeholders) {
+    const p = ph.placement;
+    xml += openTag("p:sp");
+    xml += tag(
+      "p:nvSpPr",
+      void 0,
+      tag("p:cNvPr", { id: String(spId), name: `${ph.type} ${ph.idx ?? spId}` }) + tag("p:cNvSpPr", void 0, tag("a:spLocks", { noGrp: "1" })) + tag(
+        "p:nvPr",
+        void 0,
+        tag("p:ph", {
+          type: ph.type,
+          ...ph.idx !== void 0 ? { idx: String(ph.idx) } : {}
+        })
+      )
+    );
+    xml += tag(
+      "p:spPr",
+      void 0,
+      tag(
+        "a:xfrm",
+        void 0,
+        tag("a:off", { x: inchesToEmu(p.x), y: inchesToEmu(p.y) }) + tag("a:ext", { cx: inchesToEmu(p.w), cy: inchesToEmu(p.h) })
+      )
+    );
+    xml += closeTag("p:sp");
+    spId++;
+  }
+  xml += closeTag("p:spTree");
+  xml += closeTag("p:cSld");
+  xml += closeTag("p:sldLayout");
+  return xml;
+}
+
+// src/core/content-types.ts
+var ContentTypesBuilder = class {
+  defaults = /* @__PURE__ */ new Map();
+  overrides = /* @__PURE__ */ new Map();
+  addDefault(extension, contentType) {
+    this.defaults.set(extension, contentType);
+  }
+  addOverride(partName, contentType) {
+    this.overrides.set(partName, contentType);
+  }
+  toXml() {
+    let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+    xml += '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">';
+    for (const [ext, ct] of this.defaults) {
+      xml += tag("Default", { Extension: ext, ContentType: ct });
+    }
+    for (const [pn, ct] of this.overrides) {
+      xml += tag("Override", { PartName: pn, ContentType: ct });
+    }
+    xml += "</Types>";
+    return xml;
+  }
+};
+
+// src/ooxml/serializers/content-types.ts
+function buildContentTypes(opts) {
+  const { slideCount, imageExtensions, chartCount, notesCount, layoutCount } = opts;
+  const ct = new ContentTypesBuilder();
+  ct.addDefault("rels", CONTENT_TYPE.rels);
+  ct.addDefault("xml", "application/xml");
+  for (const ext of imageExtensions) {
+    const map = {
+      png: CONTENT_TYPE.png,
+      jpeg: CONTENT_TYPE.jpeg,
+      jpg: CONTENT_TYPE.jpeg,
+      gif: CONTENT_TYPE.gif,
+      svg: CONTENT_TYPE.svg
+    };
+    if (map[ext]) ct.addDefault(ext, map[ext]);
+  }
+  ct.addOverride("/ppt/presentation.xml", CONTENT_TYPE.presentation);
+  ct.addOverride("/ppt/theme/theme1.xml", CONTENT_TYPE.theme);
+  ct.addOverride("/ppt/slideMasters/slideMaster1.xml", CONTENT_TYPE.slideMaster);
+  ct.addOverride("/ppt/presProps.xml", CONTENT_TYPE.presProps);
+  ct.addOverride("/ppt/viewProps.xml", CONTENT_TYPE.viewProps);
+  for (let i = 1; i <= layoutCount; i++) {
+    ct.addOverride(`/ppt/slideLayouts/slideLayout${i}.xml`, CONTENT_TYPE.slideLayout);
+  }
+  for (let i = 1; i <= slideCount; i++) {
+    ct.addOverride(`/ppt/slides/slide${i}.xml`, CONTENT_TYPE.slide);
+  }
+  for (let i = 1; i <= chartCount; i++) {
+    ct.addOverride(
+      `/ppt/charts/chart${i}.xml`,
+      "application/vnd.openxmlformats-officedocument.drawingml.chart+xml"
+    );
+  }
+  for (let i = 1; i <= notesCount; i++) {
+    ct.addOverride(`/ppt/notesSlides/notesSlide${i}.xml`, CONTENT_TYPE.notesSlide);
+  }
+  if (opts.hasNotesMaster) {
+    ct.addOverride("/ppt/notesMasters/notesMaster1.xml", CONTENT_TYPE.notesMaster);
+  }
+  if (opts.hasHandoutMaster) {
+    ct.addOverride("/ppt/handoutMasters/handoutMaster1.xml", CONTENT_TYPE.handoutMaster);
+  }
+  if (opts.hasCommentAuthors) {
+    ct.addOverride("/ppt/commentAuthors.xml", CONTENT_TYPE.commentAuthors);
+  }
+  const commentCount = opts.commentCount ?? 0;
+  for (let i = 1; i <= commentCount; i++) {
+    ct.addOverride(`/ppt/comments/comment${i}.xml`, CONTENT_TYPE.comments);
+  }
+  const tagCount = opts.tagCount ?? 0;
+  for (let i = 1; i <= tagCount; i++) {
+    ct.addOverride(`/ppt/tags/tag${i}.xml`, CONTENT_TYPE.tags);
+  }
+  const syncDataCount = opts.syncDataCount ?? 0;
+  for (let i = 1; i <= syncDataCount; i++) {
+    ct.addOverride(`/ppt/slideUpdateInfo/slideUpdateInfo${i}.xml`, CONTENT_TYPE.slideUpdateInfo);
+  }
+  return ct.toXml();
+}
+
+// src/ooxml/serializers/notes.ts
+function serializeNotesSlide(notes) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:notes", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  });
+  xml += openTag("p:cSld");
+  xml += openTag("p:spTree");
+  xml += tag(
+    "p:nvGrpSpPr",
+    void 0,
+    tag("p:cNvPr", { id: "1", name: "" }) + tag("p:cNvGrpSpPr") + tag("p:nvPr")
+  );
+  xml += tag(
+    "p:grpSpPr",
+    void 0,
+    tag(
+      "a:xfrm",
+      void 0,
+      tag("a:off", { x: "0", y: "0" }) + tag("a:ext", { cx: "0", cy: "0" }) + tag("a:chOff", { x: "0", y: "0" }) + tag("a:chExt", { cx: "0", cy: "0" })
+    )
+  );
+  xml += openTag("p:sp");
+  xml += tag(
+    "p:nvSpPr",
+    void 0,
+    tag("p:cNvPr", { id: "2", name: "Slide Image Placeholder" }) + tag(
+      "p:cNvSpPr",
+      void 0,
+      tag("a:spLocks", { noGrp: "1", noRot: "1", noChangeAspect: "1" })
+    ) + tag("p:nvPr", void 0, tag("p:ph", { type: "sldImg" }))
+  );
+  xml += tag("p:spPr");
+  xml += closeTag("p:sp");
+  xml += openTag("p:sp");
+  xml += tag(
+    "p:nvSpPr",
+    void 0,
+    tag("p:cNvPr", { id: "3", name: "Notes Placeholder" }) + tag("p:cNvSpPr", void 0, tag("a:spLocks", { noGrp: "1" })) + tag("p:nvPr", void 0, tag("p:ph", { type: "body", idx: "1" }))
+  );
+  xml += tag("p:spPr");
+  xml += openTag("p:txBody");
+  xml += tag("a:bodyPr");
+  xml += tag("a:lstStyle");
+  const lines = notes.split("\n");
+  for (const line of lines) {
+    xml += tag(
+      "a:p",
+      void 0,
+      tag(
+        "a:r",
+        void 0,
+        tag("a:rPr", { lang: "en-US" }) + tag("a:t", void 0, escapeXml(line))
+      )
+    );
+  }
+  xml += closeTag("p:txBody");
+  xml += closeTag("p:sp");
+  xml += closeTag("p:spTree");
+  xml += closeTag("p:cSld");
+  xml += closeTag("p:notes");
+  return xml;
+}
+
+// src/ooxml/serializers/pres-props.ts
+function serializePresProps(props) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:presentationPr", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  });
+  if (props?.slideShow) {
+    const s = props.slideShow;
+    const attrs = {};
+    if (s.loop != null) attrs.loop = s.loop ? "1" : "0";
+    if (s.showNarration != null) attrs.showNarration = s.showNarration ? "1" : "0";
+    if (s.showAnimation != null) attrs.showAnimation = s.showAnimation ? "1" : "0";
+    if (s.useTimings != null) attrs.useTimings = s.useTimings ? "1" : "0";
+    xml += tag("p:showPr", attrs);
+  }
+  if (props?.print) {
+    const p = props.print;
+    const attrs = {};
+    if (p.frameSlides != null) attrs.frameSlides = p.frameSlides ? "1" : "0";
+    if (p.hiddenSlides != null) attrs.prnWhat = p.hiddenSlides ? "slides" : "slides";
+    xml += tag("p:prnPr", attrs);
+  }
+  xml += closeTag("p:presentationPr");
+  return xml;
+}
+
+// src/ooxml/serializers/view-props.ts
+function serializeViewProps(props) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  const attrs = {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  };
+  if (props?.lastView) {
+    attrs.lastView = props.lastView;
+  }
+  xml += openTag("p:viewPr", attrs);
+  xml += closeTag("p:viewPr");
+  return xml;
+}
+
+// src/ooxml/serializers/notes-master.ts
+function serializeNotesMaster() {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:notesMaster", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  });
+  xml += openTag("p:cSld");
+  xml += openTag("p:spTree");
+  xml += tag(
+    "p:nvGrpSpPr",
+    void 0,
+    tag("p:cNvPr", { id: "1", name: "" }) + tag("p:cNvGrpSpPr") + tag("p:nvPr")
+  );
+  xml += tag(
+    "p:grpSpPr",
+    void 0,
+    tag(
+      "a:xfrm",
+      void 0,
+      tag("a:off", { x: "0", y: "0" }) + tag("a:ext", { cx: "0", cy: "0" }) + tag("a:chOff", { x: "0", y: "0" }) + tag("a:chExt", { cx: "0", cy: "0" })
+    )
+  );
+  xml += closeTag("p:spTree");
+  xml += closeTag("p:cSld");
+  xml += tag("p:clrMap", {
+    bg1: "lt1",
+    tx1: "dk1",
+    bg2: "lt2",
+    tx2: "dk2",
+    accent1: "accent1",
+    accent2: "accent2",
+    accent3: "accent3",
+    accent4: "accent4",
+    accent5: "accent5",
+    accent6: "accent6",
+    hlink: "hlink",
+    folHlink: "folHlink"
+  });
+  xml += closeTag("p:notesMaster");
+  return xml;
+}
+
+// src/ooxml/serializers/comment-authors.ts
+function serializeCommentAuthors(authors) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:cmAuthorLst", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  });
+  for (const author of authors) {
+    xml += tag("p:cmAuthor", {
+      id: String(author.id),
+      name: author.name,
+      initials: author.initials,
+      lastIdx: String(author.lastIdx),
+      clrIdx: String(author.clrIdx)
+    });
+  }
+  xml += closeTag("p:cmAuthorLst");
+  return xml;
+}
+
+// src/ooxml/serializers/comments.ts
+function serializeComments(comments) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:cmLst", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  });
+  for (const comment of comments) {
+    const attrs = {
+      authorId: String(comment.authorId),
+      idx: String(comment.index ?? 1)
+    };
+    if (comment.date) {
+      attrs.dt = comment.date;
+    }
+    let body = "";
+    if (comment.position) {
+      body += tag("p:pos", {
+        x: String(inchesToEmu(comment.position.x)),
+        y: String(inchesToEmu(comment.position.y))
+      });
+    } else {
+      body += tag("p:pos", { x: "0", y: "0" });
+    }
+    body += tag("p:text", void 0, comment.text);
+    xml += tag("p:cm", attrs, body);
+  }
+  xml += closeTag("p:cmLst");
+  return xml;
+}
+
+// src/ooxml/serializers/handout-master.ts
+function serializeHandoutMaster() {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:handoutMaster", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  });
+  xml += openTag("p:cSld");
+  xml += openTag("p:spTree");
+  xml += tag(
+    "p:nvGrpSpPr",
+    void 0,
+    tag("p:cNvPr", { id: "1", name: "" }) + tag("p:cNvGrpSpPr") + tag("p:nvPr")
+  );
+  xml += tag(
+    "p:grpSpPr",
+    void 0,
+    tag(
+      "a:xfrm",
+      void 0,
+      tag("a:off", { x: "0", y: "0" }) + tag("a:ext", { cx: "0", cy: "0" }) + tag("a:chOff", { x: "0", y: "0" }) + tag("a:chExt", { cx: "0", cy: "0" })
+    )
+  );
+  xml += closeTag("p:spTree");
+  xml += closeTag("p:cSld");
+  xml += tag("p:clrMap", {
+    bg1: "lt1",
+    tx1: "dk1",
+    bg2: "lt2",
+    tx2: "dk2",
+    accent1: "accent1",
+    accent2: "accent2",
+    accent3: "accent3",
+    accent4: "accent4",
+    accent5: "accent5",
+    accent6: "accent6",
+    hlink: "hlink",
+    folHlink: "folHlink"
+  });
+  xml += closeTag("p:handoutMaster");
+  return xml;
+}
+
+// src/ooxml/serializers/tags.ts
+function serializeTags(tags) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:tagLst", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p
+  });
+  for (const t of tags) {
+    xml += tag("p:tag", { name: t.name, val: t.value });
+  }
+  xml += closeTag("p:tagLst");
+  return xml;
+}
+
+// src/ooxml/serializers/slide-update-info.ts
+function serializeSlideUpdateInfo(data) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("p:sldSyncPr", {
+    "xmlns:a": NAMESPACE.a,
+    "xmlns:r": NAMESPACE.r,
+    "xmlns:p": NAMESPACE.p,
+    serverSldId: data.serverSldId,
+    serverSldModifiedTime: data.serverSldModifiedTime,
+    clientInsertedTime: data.clientInsertedTime
+  });
+  xml += closeTag("p:sldSyncPr");
+  return xml;
+}
+
+// src/ooxml/serializers/core-props.ts
+function serializeCoreProperties(props) {
+  let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  xml += openTag("cp:coreProperties", {
+    "xmlns:cp": "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+    "xmlns:dc": "http://purl.org/dc/elements/1.1/",
+    "xmlns:dcterms": "http://purl.org/dc/terms/",
+    "xmlns:dcmitype": "http://purl.org/dc/dcmitype/",
+    "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance"
+  });
+  if (props.title) xml += tag("dc:title", void 0, props.title);
+  if (props.creator) xml += tag("dc:creator", void 0, props.creator);
+  if (props.subject) xml += tag("dc:subject", void 0, props.subject);
+  if (props.description) xml += tag("dc:description", void 0, props.description);
+  if (props.keywords) xml += tag("cp:keywords", void 0, props.keywords);
+  if (props.category) xml += tag("cp:category", void 0, props.category);
+  xml += closeTag("cp:coreProperties");
+  return xml;
+}
+
+// src/io/writer.ts
+var encoder = new TextEncoder();
+function writePresentation(input) {
+  const { slides, theme, registry, masters, layouts } = input;
+  const files = {};
+  const allMedia = /* @__PURE__ */ new Map();
+  const imageExtensions = /* @__PURE__ */ new Set();
+  const presRels = new RelationshipManager();
+  presRels.add(REL_TYPE.slideMaster, "slideMasters/slideMaster1.xml");
+  presRels.add(REL_TYPE.theme, "theme/theme1.xml");
+  const slideRIds = [];
+  for (let i = 0; i < slides.length; i++) {
+    const rId = presRels.add(REL_TYPE.slide, `slides/slide${i + 1}.xml`);
+    slideRIds.push(rId);
+  }
+  presRels.add(REL_TYPE.presProps, "presProps.xml");
+  files["ppt/presProps.xml"] = encoder.encode(serializePresProps(input.presProps));
+  presRels.add(REL_TYPE.viewProps, "viewProps.xml");
+  files["ppt/viewProps.xml"] = encoder.encode(serializeViewProps(input.viewProps));
+  let chartCount = 0;
+  let notesCount = 0;
+  let commentCount = 0;
+  let tagCount = 0;
+  const hasNotes = slides.some((s) => s.notes);
+  const hasComments = input.commentAuthors && input.commentAuthors.length > 0 && slides.some((s) => s.comments?.length);
+  if (hasNotes) {
+    presRels.add(REL_TYPE.notesMaster, "notesMasters/notesMaster1.xml");
+    files["ppt/notesMasters/notesMaster1.xml"] = encoder.encode(serializeNotesMaster());
+    const notesMasterRels = new RelationshipManager();
+    notesMasterRels.add(REL_TYPE.theme, "../theme/theme1.xml");
+    files["ppt/notesMasters/_rels/notesMaster1.xml.rels"] = encoder.encode(notesMasterRels.toXml());
+  }
+  if (input.handoutMaster) {
+    presRels.add(REL_TYPE.handoutMaster, "handoutMasters/handoutMaster1.xml");
+    files["ppt/handoutMasters/handoutMaster1.xml"] = encoder.encode(serializeHandoutMaster());
+    const handoutMasterRels = new RelationshipManager();
+    handoutMasterRels.add(REL_TYPE.theme, "../theme/theme1.xml");
+    files["ppt/handoutMasters/_rels/handoutMaster1.xml.rels"] = encoder.encode(
+      handoutMasterRels.toXml()
+    );
+  }
+  if (hasComments && input.commentAuthors) {
+    presRels.add(REL_TYPE.commentAuthors, "commentAuthors.xml");
+    files["ppt/commentAuthors.xml"] = encoder.encode(serializeCommentAuthors(input.commentAuthors));
+  }
+  if (input.tags && input.tags.length > 0) {
+    tagCount++;
+    presRels.add(REL_TYPE.tags, `tags/tag${tagCount}.xml`);
+    files[`ppt/tags/tag${tagCount}.xml`] = encoder.encode(serializeTags(input.tags));
+  }
+  if (input.htmlPublishUri) {
+    presRels.add(REL_TYPE.htmlPubSaveAs, input.htmlPublishUri, void 0, true);
+  }
+  for (let i = 0; i < slides.length; i++) {
+    const layoutIdx = slides[i].layoutIndex ?? 0;
+    const result = serializeSlide(
+      slides[i].elements,
+      i,
+      theme,
+      registry,
+      `rId1`,
+      slides[i].transition,
+      slides[i].animations,
+      slides[i].background
+    );
+    files[`ppt/slides/slide${i + 1}.xml`] = encoder.encode(result.slideXml);
+    for (const [path, data] of result.media) {
+      allMedia.set(path, data);
+      if (path.startsWith("ppt/charts/")) {
+        chartCount++;
+      } else {
+        const ext = path.split(".").pop() ?? "bin";
+        imageExtensions.add(ext);
+      }
+    }
+    const slideRelManager = new RelationshipManager();
+    slideRelManager.add(REL_TYPE.slideLayout, `../slideLayouts/slideLayout${layoutIdx + 1}.xml`);
+    if (slides[i].notes) {
+      notesCount++;
+      const notesRel = new RelationshipManager();
+      notesRel.add(REL_TYPE.slide, `../slides/slide${i + 1}.xml`);
+      notesRel.add(REL_TYPE.notesMaster, "../notesMasters/notesMaster1.xml");
+      const notesXml = serializeNotesSlide(slides[i].notes ?? "");
+      files[`ppt/notesSlides/notesSlide${notesCount}.xml`] = encoder.encode(notesXml);
+      files[`ppt/notesSlides/_rels/notesSlide${notesCount}.xml.rels`] = encoder.encode(
+        notesRel.toXml()
+      );
+      slideRelManager.add(REL_TYPE.notesSlide, `../notesSlides/notesSlide${notesCount}.xml`);
+    }
+    const slideComments = slides[i].comments;
+    if (slideComments && slideComments.length > 0) {
+      commentCount++;
+      slideRelManager.add(REL_TYPE.comments, `../comments/comment${commentCount}.xml`);
+      files[`ppt/comments/comment${commentCount}.xml`] = encoder.encode(
+        serializeComments(slideComments)
+      );
+    }
+    const slideTags = slides[i].tags;
+    if (slideTags && slideTags.length > 0) {
+      tagCount++;
+      slideRelManager.add(REL_TYPE.tags, `../tags/tag${tagCount}.xml`);
+      files[`ppt/tags/tag${tagCount}.xml`] = encoder.encode(serializeTags(slideTags));
+    }
+    const syncData = slides[i].syncData;
+    if (syncData) {
+      slideRelManager.add(
+        REL_TYPE.slideUpdateInfo,
+        `../slideUpdateInfo/slideUpdateInfo${i + 1}.xml`
+      );
+      files[`ppt/slideUpdateInfo/slideUpdateInfo${i + 1}.xml`] = encoder.encode(
+        serializeSlideUpdateInfo(syncData)
+      );
+      if (input.slideUpdateUrl) {
+        const syncRels = new RelationshipManager();
+        syncRels.add(REL_TYPE.slideUpdateUrl, input.slideUpdateUrl, void 0, true);
+        files[`ppt/slideUpdateInfo/_rels/slideUpdateInfo${i + 1}.xml.rels`] = encoder.encode(
+          syncRels.toXml()
+        );
+      }
+    }
+    for (const rel of result.mediaRels) {
+      slideRelManager.add(rel.type, rel.target);
+    }
+    files[`ppt/slides/_rels/slide${i + 1}.xml.rels`] = encoder.encode(slideRelManager.toXml());
+  }
+  files["ppt/theme/theme1.xml"] = encoder.encode(serializeTheme(theme));
+  for (let i = 0; i < masters.length; i++) {
+    files[`ppt/slideMasters/slideMaster${i + 1}.xml`] = encoder.encode(
+      serializeSlideMaster(masters[i], layouts.length)
+    );
+    const masterRels = new RelationshipManager();
+    for (let j = 0; j < layouts.length; j++) {
+      masterRels.add(REL_TYPE.slideLayout, `../slideLayouts/slideLayout${j + 1}.xml`);
+    }
+    masterRels.add(REL_TYPE.theme, "../theme/theme1.xml");
+    files[`ppt/slideMasters/_rels/slideMaster${i + 1}.xml.rels`] = encoder.encode(
+      masterRels.toXml()
+    );
+  }
+  for (let i = 0; i < layouts.length; i++) {
+    files[`ppt/slideLayouts/slideLayout${i + 1}.xml`] = encoder.encode(
+      serializeSlideLayout(layouts[i])
+    );
+    const layoutRels = new RelationshipManager();
+    layoutRels.add(REL_TYPE.slideMaster, "../slideMasters/slideMaster1.xml");
+    files[`ppt/slideLayouts/_rels/slideLayout${i + 1}.xml.rels`] = encoder.encode(
+      layoutRels.toXml()
+    );
+  }
+  files["[Content_Types].xml"] = encoder.encode(
+    buildContentTypes({
+      slideCount: slides.length,
+      imageExtensions,
+      chartCount,
+      notesCount,
+      layoutCount: layouts.length,
+      hasNotesMaster: hasNotes,
+      hasHandoutMaster: !!input.handoutMaster,
+      commentCount,
+      hasCommentAuthors: !!hasComments,
+      tagCount,
+      syncDataCount: slides.filter((s) => s.syncData).length
+    })
+  );
+  files["ppt/presentation.xml"] = encoder.encode(
+    serializePresentation(slides.length, slideRIds, input.slideSize)
+  );
+  files["ppt/_rels/presentation.xml.rels"] = encoder.encode(presRels.toXml());
+  if (input.coreProperties) {
+    files["docProps/core.xml"] = encoder.encode(serializeCoreProperties(input.coreProperties));
+  }
+  const rootRels = new RelationshipManager();
+  rootRels.add(REL_TYPE.officeDocument, "ppt/presentation.xml");
+  if (input.coreProperties) {
+    rootRels.add(
+      "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
+      "docProps/core.xml"
+    );
+  }
+  files["_rels/.rels"] = encoder.encode(rootRels.toXml());
+  for (const [path, data] of allMedia) {
+    files[path] = data;
+  }
+  return zipSync(files);
+}
+
+// src/elements/base.ts
+var BaseElement = class {
+  /** Position and size of the element on the slide. */
+  placement;
+  /** Optional human-readable name for the element. */
+  name;
+  constructor(placement, name) {
+    this.placement = placement;
+    this.name = name;
+  }
+};
+
+// src/elements/text.ts
+var TextElement = class _TextElement extends BaseElement {
+  /** Element type discriminator. */
+  type = "text";
+  /** Paragraphs that make up the text content. */
+  paragraphs;
+  /** Options controlling the text body (margins, wrapping, auto-fit, etc.). */
+  bodyOptions;
+  /** Background fill for the text box. */
+  fill;
+  /** Outline/border properties for the text box. */
+  line;
+  /** Visual effects (shadow, glow, etc.). */
+  effects;
+  /** 2-D transform (rotation, flip). */
+  transform;
+  /** 3D scene (camera + lighting). */
+  scene3d;
+  /** 3D shape (extrusion, bevels, material). */
+  shape3d;
+  constructor(paragraphs, placement, name, opts) {
+    super(placement, name);
+    this.paragraphs = paragraphs;
+    this.bodyOptions = opts?.bodyOptions;
+    this.fill = opts?.fill;
+    this.line = opts?.line;
+    this.effects = opts?.effects;
+    this.transform = opts?.transform;
+    this.scene3d = opts?.scene3d;
+    this.shape3d = opts?.shape3d;
+  }
+  /**
+   * Creates a TextElement from a plain string, splitting on newlines into paragraphs.
+   * @param text - Plain text content (newlines become paragraph breaks).
+   * @param placement - Position and size on the slide.
+   * @param runOptions - Optional formatting for all text runs.
+   * @param paraOptions - Optional paragraph-level formatting.
+   * @param bodyOptions - Optional text body options.
+   * @returns A new TextElement instance.
+   */
+  static fromString(text, placement, runOptions, paraOptions, bodyOptions) {
+    const lines = text.split("\n");
+    const paragraphs = lines.map((line) => ({
+      runs: [{ text: line, options: runOptions }],
+      options: paraOptions
+    }));
+    return new _TextElement(paragraphs, placement, void 0, { bodyOptions });
+  }
+};
+
+// src/elements/image.ts
+var ImageElement = class extends BaseElement {
+  /** Element type discriminator. */
+  type = "image";
+  /** File system path to the image (mutually exclusive with `data`). */
+  path;
+  /** Raw image bytes (mutually exclusive with `path`). */
+  data;
+  /** MIME type of the image (defaults to 'image/png'). */
+  contentType;
+  /** Border/outline properties for the image. */
+  border;
+  /** Visual effects (shadow, glow, etc.). */
+  effects;
+  /** 2-D transform (rotation, flip). */
+  transform;
+  /** Image opacity, 0-100. */
+  opacity;
+  /** Crop offsets as fractions (0-1) from each edge. */
+  crop;
+  /** Hyperlink attached to the image. */
+  hyperlink;
+  /** Whether to lock the aspect ratio when resizing. */
+  lockAspectRatio;
+  /** 3D scene (camera + lighting). */
+  scene3d;
+  /** 3D shape (extrusion, bevels, material). */
+  shape3d;
+  brightness;
+  contrast;
+  saturation;
+  duotone;
+  cropShape;
+  constructor(placement, opts) {
+    super(placement);
+    this.path = opts.path;
+    this.data = opts.data;
+    this.contentType = opts.contentType ?? "image/png";
+    this.border = opts.border;
+    this.effects = opts.effects;
+    this.transform = opts.transform;
+    this.opacity = opts.opacity;
+    this.crop = opts.crop;
+    this.hyperlink = opts.hyperlink;
+    this.lockAspectRatio = opts.lockAspectRatio;
+    this.scene3d = opts.scene3d;
+    this.shape3d = opts.shape3d;
+    this.brightness = opts.brightness;
+    this.contrast = opts.contrast;
+    this.saturation = opts.saturation;
+    this.duotone = opts.duotone;
+    this.cropShape = opts.cropShape;
+  }
+};
+
+// src/elements/shape.ts
+var ShapeElement = class extends BaseElement {
+  /** Element type discriminator. */
+  type = "shape";
+  /** Preset geometry type (e.g. 'rect', 'ellipse', 'roundRect'). */
+  geometry;
+  /** Background fill for the shape. */
+  fill;
+  /** Outline/border properties. */
+  line;
+  /** Visual effects (shadow, glow, etc.). */
+  effects;
+  /** 2-D transform (rotation, flip). */
+  transform;
+  /** Shape opacity, 0-100. */
+  opacity;
+  /** Plain text content rendered inside the shape. */
+  text;
+  /** Text body options for text rendered inside the shape. */
+  textOptions;
+  /** Run-level formatting for the shape's text. */
+  textRunOptions;
+  /** Paragraph-level formatting for the shape's text. */
+  textParagraphOptions;
+  /** Geometry adjustment values keyed by handle name. */
+  adjustValues;
+  /** Hyperlink attached to the shape. */
+  hyperlink;
+  /** 3D scene (camera + lighting). */
+  scene3d;
+  /** 3D shape (extrusion, bevels, material). */
+  shape3d;
+  /** Custom geometry (overrides preset). */
+  customGeometry;
+  /** Shape protection locks. */
+  locks;
+  constructor(geometry, placement, opts) {
+    super(placement);
+    this.geometry = geometry;
+    this.fill = opts?.fill;
+    this.line = opts?.line;
+    this.effects = opts?.effects;
+    this.transform = opts?.transform;
+    this.opacity = opts?.opacity;
+    this.text = opts?.text;
+    this.textOptions = opts?.textOptions;
+    this.textRunOptions = opts?.textRunOptions;
+    this.textParagraphOptions = opts?.textParagraphOptions;
+    this.adjustValues = opts?.adjustValues;
+    this.hyperlink = opts?.hyperlink;
+    this.scene3d = opts?.scene3d;
+    this.shape3d = opts?.shape3d;
+    this.customGeometry = opts?.customGeometry;
+    this.locks = opts?.locks;
+  }
+};
+
+// src/elements/table.ts
+var TableElement = class extends BaseElement {
+  /** Element type discriminator. */
+  type = "table";
+  /** Row data including cells and per-row options. */
+  rows;
+  /** Column widths in EMUs. */
+  colWidths;
+  /** Row heights in EMUs. */
+  rowHeights;
+  /** Border configuration for the table. */
+  border;
+  /** Default background fill for cells. */
+  fill;
+  /** Apply special formatting to the first row. */
+  firstRow;
+  /** Apply special formatting to the last row. */
+  lastRow;
+  /** Apply special formatting to the first column. */
+  firstCol;
+  /** Apply special formatting to the last column. */
+  lastCol;
+  /** Enable row banding (alternating row colors). */
+  bandRow;
+  /** Enable column banding (alternating column colors). */
+  bandCol;
+  /** Pair of colors for alternating row bands. */
+  bandRowColors;
+  /** Visual effects (shadow, glow, etc.). */
+  effects;
+  /** 2-D transform (rotation, flip). */
+  transform;
+  /** Built-in table style GUID. */
+  tableStyleId;
+  constructor(rows, placement, opts) {
+    super(placement);
+    this.rows = rows;
+    this.colWidths = opts?.colWidths;
+    this.rowHeights = opts?.rowHeights;
+    this.border = opts?.border;
+    this.fill = opts?.fill;
+    this.firstRow = opts?.firstRow;
+    this.lastRow = opts?.lastRow;
+    this.firstCol = opts?.firstCol;
+    this.lastCol = opts?.lastCol;
+    this.bandRow = opts?.bandRow;
+    this.bandCol = opts?.bandCol;
+    this.bandRowColors = opts?.bandRowColors;
+    this.effects = opts?.effects;
+    this.transform = opts?.transform;
+    this.tableStyleId = opts?.tableStyleId;
+  }
+};
+
+// src/elements/chart.ts
+var ChartElement = class extends BaseElement {
+  /** Element type discriminator. */
+  type = "chart";
+  /** The kind of chart to render (e.g. 'bar', 'line', 'pie'). */
+  chartType;
+  /** Series and category data for the chart. */
+  data;
+  /** Optional chart title text. */
+  title;
+  /** Whether to display the legend (defaults to true). */
+  showLegend;
+  /** Whether to show data labels on data points (defaults to false). */
+  showDataLabels;
+  /** Whether to display grid lines (defaults to true). */
+  showGridLines;
+  /** Font size for the chart title, in points. */
+  titleFontSize;
+  /** Color for the chart title. */
+  titleColor;
+  /** Position of the legend relative to the chart. */
+  legendPosition;
+  /** Category (horizontal) axis options. */
+  catAxis;
+  /** Primary value (vertical) axis options. */
+  valAxis;
+  /** Secondary value axis options (for combo charts). */
+  secondaryValAxis;
+  /** Plot area background fill and border. */
+  plotArea;
+  /** Gap width between bar groups, as a percentage. */
+  barGapWidth;
+  /** Overlap between bars in a group, as a percentage (-100 to 100). */
+  barOverlap;
+  /** Grouping mode for bar/column charts. */
+  barGrouping;
+  /** Explosion distance for pie slices, as a percentage. */
+  pieExplosion;
+  /** Hole size for doughnut charts, as a percentage (0-90). */
+  doughnutHoleSize;
+  /** Grouping mode for line charts. */
+  lineGrouping;
+  /** Grouping mode for area charts. */
+  areaGrouping;
+  /** Rendering style for scatter charts. */
+  scatterStyle;
+  /** Rendering style for radar charts. */
+  radarStyle;
+  /** Chart border/outline properties. */
+  border;
+  /** Chart background fill color. */
+  fill;
+  /** Chart-level data label configuration. */
+  dataLabels;
+  /** 3-D view settings for the chart. */
+  view3D;
+  constructor(chartType, data, placement, opts) {
+    super(placement);
+    this.chartType = chartType;
+    this.data = data;
+    this.title = opts?.title;
+    this.showLegend = opts?.showLegend ?? true;
+    this.showDataLabels = opts?.showDataLabels ?? false;
+    this.showGridLines = opts?.showGridLines ?? true;
+    this.titleFontSize = opts?.titleFontSize;
+    this.titleColor = opts?.titleColor;
+    this.legendPosition = opts?.legendPosition;
+    this.catAxis = opts?.catAxis;
+    this.valAxis = opts?.valAxis;
+    this.secondaryValAxis = opts?.secondaryValAxis;
+    this.plotArea = opts?.plotArea;
+    this.barGapWidth = opts?.barGapWidth;
+    this.barOverlap = opts?.barOverlap;
+    this.barGrouping = opts?.barGrouping;
+    this.pieExplosion = opts?.pieExplosion;
+    this.doughnutHoleSize = opts?.doughnutHoleSize;
+    this.lineGrouping = opts?.lineGrouping;
+    this.areaGrouping = opts?.areaGrouping;
+    this.scatterStyle = opts?.scatterStyle;
+    this.radarStyle = opts?.radarStyle;
+    this.border = opts?.border;
+    this.fill = opts?.fill;
+    this.dataLabels = opts?.dataLabels;
+    this.view3D = opts?.view3D;
+  }
+};
+
+// src/elements/media.ts
+var MediaElement = class extends BaseElement {
+  /** Element type discriminator. */
+  type = "media";
+  /** Whether this is a video or audio element. */
+  mediaType;
+  /** File system path to the media file (mutually exclusive with `data`). */
+  path;
+  /** Raw media bytes (mutually exclusive with `path`). */
+  data;
+  /** MIME type (defaults to 'video/mp4' or 'audio/mpeg' based on mediaType). */
+  contentType;
+  /** Poster/thumbnail image displayed before playback. */
+  poster;
+  /** Playback settings (autoplay, loop, etc.). */
+  playback;
+  /** Visual effects (shadow, glow, etc.). */
+  effects;
+  /** 2-D transform (rotation, flip). */
+  transform;
+  constructor(mediaType, placement, opts) {
+    super(placement);
+    this.mediaType = mediaType;
+    this.path = opts.path;
+    this.data = opts.data;
+    this.contentType = opts.contentType ?? (mediaType === "video" ? "video/mp4" : "audio/mpeg");
+    this.poster = opts.poster;
+    this.playback = opts.playback;
+    this.effects = opts.effects;
+    this.transform = opts.transform;
+  }
+};
+
+// src/elements/group.ts
+var GroupElement = class extends BaseElement {
+  /** Element type discriminator. */
+  type = "group";
+  /** Child elements contained within this group. */
+  children;
+  constructor(children, placement, name) {
+    super(placement, name);
+    this.children = children;
+  }
+};
+
+// src/elements/connector.ts
+var ConnectorElement = class extends BaseElement {
+  /** Element type discriminator. */
+  type = "connector";
+  /** The connector routing style (defaults to 'straight'). */
+  connectorType;
+  /** Line formatting (color, width, dash style, etc.). */
+  line;
+  /** Arrowhead properties for the start of the connector. */
+  startArrow;
+  /** Arrowhead properties for the end of the connector. */
+  endArrow;
+  constructor(placement, opts) {
+    super(placement);
+    this.connectorType = opts?.type ?? "straight";
+    this.line = opts?.line;
+    this.startArrow = opts?.startArrow;
+    this.endArrow = opts?.endArrow;
+  }
+};
+
+// src/builder/slide-builder.ts
+function placementFromOpts(opts) {
+  return {
+    x: opts.x ?? 0,
+    y: opts.y ?? 0,
+    w: opts.w ?? 5,
+    h: opts.h ?? 1
+  };
+}
+var SlideBuilder = class {
+  data;
+  commentAuthors;
+  constructor(data, commentAuthors) {
+    this.data = data;
+    this.commentAuthors = commentAuthors;
+  }
+  /** Adds a text box to the slide. Placement dimensions are in inches. */
+  addText(text, opts = {}) {
+    const placement = placementFromOpts(opts);
+    const element = TextElement.fromString(
+      text,
+      placement,
+      {
+        bold: opts.bold,
+        italic: opts.italic,
+        underline: opts.underline,
+        strikethrough: opts.strikethrough,
+        fontSize: opts.fontSize,
+        fontFace: opts.fontFace,
+        color: opts.color,
+        subscript: opts.subscript,
+        superscript: opts.superscript,
+        highlight: opts.highlight,
+        letterSpacing: opts.letterSpacing,
+        baseline: opts.baseline,
+        hyperlink: opts.hyperlink,
+        outline: opts.outline,
+        shadow: opts.shadow,
+        caps: opts.caps,
+        lang: opts.lang
+      },
+      {
+        align: opts.align,
+        lineSpacing: opts.lineSpacing,
+        spaceBefore: opts.spaceBefore,
+        spaceAfter: opts.spaceAfter,
+        indent: opts.indent,
+        marginLeft: opts.marginLeft,
+        level: opts.level,
+        rtl: opts.rtl,
+        bullet: opts.bullet,
+        numbering: opts.numbering,
+        tabStops: opts.tabStops,
+        defaultRunOptions: opts.defaultRunOptions
+      },
+      {
+        verticalAlign: opts.verticalAlign,
+        textDirection: opts.textDirection,
+        wordWrap: opts.wordWrap,
+        autoFit: opts.autoFit,
+        margin: opts.margin,
+        columns: opts.columns,
+        columnSpacing: opts.columnSpacing
+      }
+    );
+    if (opts.fill) element.fill = opts.fill;
+    if (opts.line) element.line = opts.line;
+    if (opts.effects) element.effects = opts.effects;
+    if (opts.transform) element.transform = opts.transform;
+    if (opts.scene3d) element.scene3d = opts.scene3d;
+    if (opts.shape3d) element.shape3d = opts.shape3d;
+    this.data.elements.push(element);
+    return this;
+  }
+  /** Adds an image to the slide from a file path or binary data. */
+  addImage(opts) {
+    const placement = placementFromOpts(opts);
+    const element = new ImageElement(placement, {
+      path: opts.path,
+      data: opts.data,
+      contentType: opts.contentType,
+      border: opts.border,
+      effects: opts.effects,
+      transform: opts.transform,
+      opacity: opts.opacity,
+      crop: opts.crop,
+      hyperlink: opts.hyperlink,
+      lockAspectRatio: opts.lockAspectRatio,
+      scene3d: opts.scene3d,
+      shape3d: opts.shape3d,
+      brightness: opts.brightness,
+      contrast: opts.contrast,
+      saturation: opts.saturation,
+      duotone: opts.duotone,
+      cropShape: opts.cropShape
+    });
+    this.data.elements.push(element);
+    return this;
+  }
+  /** Adds a preset geometry shape to the slide. */
+  addShape(geometry, opts = {}) {
+    const placement = placementFromOpts(opts);
+    const element = new ShapeElement(geometry, placement, {
+      fill: opts.fill,
+      line: opts.line,
+      effects: opts.effects,
+      transform: opts.transform,
+      opacity: opts.opacity,
+      text: opts.text,
+      textOptions: opts.textOptions,
+      textRunOptions: opts.textRunOptions,
+      textParagraphOptions: opts.textParagraphOptions,
+      adjustValues: opts.adjustValues,
+      hyperlink: opts.hyperlink,
+      scene3d: opts.scene3d,
+      shape3d: opts.shape3d,
+      customGeometry: opts.customGeometry,
+      locks: opts.locks
+    });
+    this.data.elements.push(element);
+    return this;
+  }
+  /** Adds a table to the slide. */
+  addTable(rows, opts = {}) {
+    const placement = placementFromOpts(opts);
+    const element = new TableElement(rows, placement, {
+      colWidths: opts.colWidths,
+      rowHeights: opts.rowHeights,
+      border: opts.border,
+      fill: opts.fill,
+      firstRow: opts.firstRow,
+      lastRow: opts.lastRow,
+      firstCol: opts.firstCol,
+      lastCol: opts.lastCol,
+      bandRow: opts.bandRow,
+      bandCol: opts.bandCol,
+      bandRowColors: opts.bandRowColors,
+      effects: opts.effects,
+      transform: opts.transform,
+      tableStyleId: opts.tableStyleId
+    });
+    this.data.elements.push(element);
+    return this;
+  }
+  /** Adds a chart to the slide. Defaults to 6x4 inches if width/height are not specified. */
+  addChart(type, data, opts = {}) {
+    const placement = placementFromOpts({ ...opts, w: opts.w ?? 6, h: opts.h ?? 4 });
+    const element = new ChartElement(type, data, placement, {
+      title: opts.title,
+      showLegend: opts.showLegend,
+      showDataLabels: opts.showDataLabels,
+      showGridLines: opts.showGridLines,
+      titleFontSize: opts.titleFontSize,
+      titleColor: opts.titleColor,
+      legendPosition: opts.legendPosition,
+      catAxis: opts.catAxis,
+      valAxis: opts.valAxis,
+      secondaryValAxis: opts.secondaryValAxis,
+      plotArea: opts.plotArea,
+      barGapWidth: opts.barGapWidth,
+      barOverlap: opts.barOverlap,
+      barGrouping: opts.barGrouping,
+      pieExplosion: opts.pieExplosion,
+      doughnutHoleSize: opts.doughnutHoleSize,
+      lineGrouping: opts.lineGrouping,
+      areaGrouping: opts.areaGrouping,
+      scatterStyle: opts.scatterStyle,
+      radarStyle: opts.radarStyle,
+      border: opts.border,
+      fill: opts.fill,
+      dataLabels: opts.dataLabels,
+      view3D: opts.view3D
+    });
+    this.data.elements.push(element);
+    return this;
+  }
+  /** Sets speaker notes text for this slide. */
+  setNotes(notes) {
+    this.data.notes = notes;
+    return this;
+  }
+  /** Adds a video element to the slide. Defaults to 6x4 inches. */
+  addVideo(opts) {
+    const placement = placementFromOpts({ ...opts, w: opts.w ?? 6, h: opts.h ?? 4 });
+    const element = new MediaElement("video", placement, {
+      path: opts.path,
+      data: opts.data,
+      contentType: opts.contentType,
+      poster: opts.poster,
+      playback: opts.playback,
+      effects: opts.effects,
+      transform: opts.transform
+    });
+    this.data.elements.push(element);
+    return this;
+  }
+  /** Adds an audio element to the slide. Defaults to 1x1 inch. */
+  addAudio(opts) {
+    const placement = placementFromOpts({ ...opts, w: opts.w ?? 1, h: opts.h ?? 1 });
+    const element = new MediaElement("audio", placement, {
+      path: opts.path,
+      data: opts.data,
+      contentType: opts.contentType,
+      poster: opts.poster,
+      playback: opts.playback,
+      effects: opts.effects,
+      transform: opts.transform
+    });
+    this.data.elements.push(element);
+    return this;
+  }
+  /** Adds a pre-built element directly to the slide. */
+  addElement(element) {
+    this.data.elements.push(element);
+    return this;
+  }
+  /**
+   * Adds a comment to the slide.
+   * @param authorId - ID returned by {@link Presentation.defineCommentAuthor}.
+   */
+  addComment(text, authorId, opts) {
+    if (!this.data.comments) this.data.comments = [];
+    if (this.commentAuthors) {
+      const author = this.commentAuthors.find((a) => a.id === authorId);
+      if (author) author.lastIdx++;
+    }
+    this.data.comments.push({
+      authorId,
+      text,
+      date: opts?.date,
+      position: opts?.position,
+      index: this.data.comments.length + 1
+    });
+    return this;
+  }
+  /** Sets user-defined tags on this slide as key-value pairs. */
+  setTags(tags) {
+    this.data.tags = Object.entries(tags).map(([name, value]) => ({ name, value }));
+    return this;
+  }
+  /** Sets synchronization data for collaborative slide updates. */
+  setSyncData(data) {
+    this.data.syncData = data;
+    return this;
+  }
+  /** Sets the transition effect for this slide. */
+  setTransition(transition) {
+    this.data.transition = transition;
+    return this;
+  }
+  /** Adds an animation to the slide's animation sequence. */
+  addAnimation(anim) {
+    if (!this.data.animations) this.data.animations = [];
+    this.data.animations.push(anim);
+    return this;
+  }
+  /** Sets the background fill or image for this slide. */
+  setBackground(bg) {
+    this.data.background = bg;
+    return this;
+  }
+  /**
+   * Adds a group of elements that are positioned and transformed together.
+   * @param buildFn - Callback receiving a {@link GroupBuilder} to populate the group.
+   */
+  addGroup(buildFn, opts = {}) {
+    const placement = placementFromOpts(opts);
+    const children = [];
+    const groupBuilder = new GroupBuilder(children);
+    buildFn(groupBuilder);
+    const element = new GroupElement(children, placement);
+    this.data.elements.push(element);
+    return this;
+  }
+  /** Adds a connector line between points on the slide. */
+  addConnector(opts) {
+    const placement = placementFromOpts(opts);
+    const element = new ConnectorElement(placement, {
+      type: opts.type,
+      line: opts.line,
+      startArrow: opts.startArrow,
+      endArrow: opts.endArrow
+    });
+    this.data.elements.push(element);
+    return this;
+  }
+};
+var GroupBuilder = class {
+  children;
+  constructor(children) {
+    this.children = children;
+  }
+  /** Adds a shape to the group. */
+  addShape(geometry, opts = {}) {
+    const placement = placementFromOpts(opts);
+    this.children.push(
+      new ShapeElement(geometry, placement, {
+        fill: opts.fill,
+        line: opts.line,
+        effects: opts.effects,
+        transform: opts.transform,
+        text: opts.text,
+        textOptions: opts.textOptions,
+        textRunOptions: opts.textRunOptions,
+        textParagraphOptions: opts.textParagraphOptions,
+        adjustValues: opts.adjustValues,
+        hyperlink: opts.hyperlink
+      })
+    );
+    return this;
+  }
+  /** Adds a text box to the group. */
+  addText(text, opts = {}) {
+    const placement = placementFromOpts(opts);
+    this.children.push(
+      TextElement.fromString(
+        text,
+        placement,
+        {
+          bold: opts.bold,
+          italic: opts.italic,
+          underline: opts.underline,
+          fontSize: opts.fontSize,
+          fontFace: opts.fontFace,
+          color: opts.color
+        },
+        { align: opts.align }
+      )
+    );
+    return this;
+  }
+  /** Adds an image to the group. */
+  addImage(opts) {
+    const placement = placementFromOpts(opts);
+    this.children.push(
+      new ImageElement(placement, {
+        path: opts.path,
+        data: opts.data,
+        contentType: opts.contentType
+      })
+    );
+    return this;
+  }
+  /** Adds a pre-built element directly to the group. */
+  addElement(element) {
+    this.children.push(element);
+    return this;
+  }
+};
+
+// src/builder/presentation-builder.ts
+var Presentation = class {
+  slides = [];
+  registry;
+  theme;
+  masters;
+  layouts;
+  layoutNameMap = /* @__PURE__ */ new Map();
+  presProps = {};
+  viewProps = {};
+  notesMaster;
+  handoutMaster;
+  commentAuthors = [];
+  authorNameMap = /* @__PURE__ */ new Map();
+  presTags = [];
+  opts;
+  /** Creates a new presentation with optional configuration. */
+  constructor(opts) {
+    this.opts = opts ?? {};
+    this.theme = {
+      ...defaultTheme,
+      ...opts?.theme,
+      colors: { ...defaultTheme.colors, ...opts?.theme?.colors },
+      fonts: { ...defaultTheme.fonts, ...opts?.theme?.fonts }
+    };
+    this.registry = new Registry();
+    this.registry.registerElement("text", textSerializer);
+    this.registry.registerElement("image", imageSerializer);
+    this.registry.registerElement("shape", shapeSerializer);
+    this.registry.registerElement("table", tableSerializer);
+    this.registry.registerElement("chart", chartSerializer);
+    this.registry.registerElement("media", mediaSerializer);
+    this.registry.registerElement("group", createGroupSerializer(this.registry));
+    this.registry.registerElement("connector", connectorSerializer);
+    this.masters = [new SlideMaster({ name: "Default Master" })];
+    this.layouts = [new SlideLayout(builtinLayouts.blank)];
+    this.layoutNameMap.set("blank", 0);
+  }
+  /** Registers a plugin to extend serialization capabilities. */
+  use(plugin) {
+    plugin.install(this.registry);
+    return this;
+  }
+  /** Defines or replaces the default slide master. */
+  defineSlideMaster(def) {
+    this.masters[0] = new SlideMaster(def);
+    return this;
+  }
+  /** Registers a new slide layout that can be referenced by name when adding slides. */
+  defineLayout(def) {
+    const idx = this.layouts.length;
+    this.layouts.push(new SlideLayout(def));
+    this.layoutNameMap.set(def.name, idx);
+    return this;
+  }
+  /** Defines the notes master for speaker notes formatting. */
+  defineNotesMaster(def) {
+    this.notesMaster = new NotesMaster(def);
+    return this;
+  }
+  /** Defines the handout master for printed handout formatting. */
+  defineHandoutMaster(def) {
+    this.handoutMaster = new HandoutMaster(def);
+    return this;
+  }
+  /** Configures slideshow playback properties (e.g., loop, timing). */
+  setShowProperties(props) {
+    this.presProps.slideShow = props;
+    return this;
+  }
+  /** Configures print-related properties. */
+  setPrintProperties(props) {
+    this.presProps.print = props;
+    return this;
+  }
+  /** Sets the default view properties (e.g., normal, slide sorter). */
+  setViewProperties(props) {
+    this.viewProps = props;
+    return this;
+  }
+  /**
+   * Registers a comment author. Returns the author ID, reusing an existing one if the name matches.
+   * @param name - Display name of the author.
+   * @param initials - Author initials shown in comment badges.
+   */
+  defineCommentAuthor(name, initials) {
+    const existing = this.authorNameMap.get(name);
+    if (existing != null) return existing;
+    const id = this.commentAuthors.length;
+    this.commentAuthors.push({ id, name, initials, lastIdx: 0, clrIdx: id });
+    this.authorNameMap.set(name, id);
+    return id;
+  }
+  /** Sets user-defined tags on the presentation as key-value pairs. */
+  setTags(tags) {
+    this.presTags = Object.entries(tags).map(([name, value]) => ({ name, value }));
+    return this;
+  }
+  /**
+   * Adds a new slide and returns a builder for populating it.
+   * @param layoutName - Name of a previously defined layout; defaults to "blank".
+   */
+  addSlide(layoutName) {
+    const layoutIndex = layoutName ? this.layoutNameMap.get(layoutName) ?? 0 : 0;
+    const slideData = { elements: [], layoutIndex };
+    this.slides.push(slideData);
+    return new SlideBuilder(slideData, this.commentAuthors);
+  }
+  /** Serializes the presentation to a PPTX file in memory and returns the raw bytes. */
+  toBuffer() {
+    return writePresentation({
+      slides: this.slides,
+      theme: this.theme,
+      registry: this.registry,
+      masters: this.masters,
+      layouts: this.layouts,
+      presProps: this.presProps,
+      viewProps: this.viewProps,
+      notesMaster: this.notesMaster,
+      commentAuthors: this.commentAuthors.length > 0 ? this.commentAuthors : void 0,
+      handoutMaster: this.handoutMaster,
+      tags: this.presTags.length > 0 ? this.presTags : void 0,
+      htmlPublishUri: this.opts.htmlPublishUri,
+      slideUpdateUrl: this.opts.slideUpdateUrl,
+      slideSize: this.opts.slideSize,
+      coreProperties: this.opts.coreProperties
+    });
+  }
+  /** Writes the presentation as a .pptx file to disk (Node.js only). */
+  async toFile(path) {
+    const { writeFile } = await import("fs/promises");
+    const buf = this.toBuffer();
+    await writeFile(path, buf);
+  }
+};
+export {
+  ChartElement,
+  ConnectorElement,
+  GroupElement,
+  HandoutMaster,
+  ImageElement,
+  MediaElement,
+  NotesMaster,
+  Presentation,
+  Registry,
+  ShapeElement,
+  SlideBuilder,
+  SlideLayout,
+  SlideMaster,
+  TableElement,
+  TextElement,
+  builtinLayouts,
+  defaultColorScheme,
+  defaultFontScheme,
+  defaultTheme
+};
+//# sourceMappingURL=index.js.map