pptx-glimpse 0.1.0

package/dist/index.js

@@ -0,0 +1,4493 @@
+// src/parser/pptx-reader.ts
+import JSZip from "jszip";
+async function readPptx(input) {
+  const zip = await JSZip.loadAsync(input);
+  const files = /* @__PURE__ */ new Map();
+  const media = /* @__PURE__ */ new Map();
+  const promises = [];
+  zip.forEach((relativePath, zipEntry) => {
+    if (zipEntry.dir) return;
+    if (relativePath.startsWith("ppt/media/")) {
+      promises.push(
+        zipEntry.async("nodebuffer").then((buf) => {
+          media.set(relativePath, buf);
+        })
+      );
+    } else if (relativePath.endsWith(".xml") || relativePath.endsWith(".rels") || relativePath === "[Content_Types].xml") {
+      promises.push(
+        zipEntry.async("string").then((str) => {
+          files.set(relativePath, str);
+        })
+      );
+    }
+  });
+  await Promise.all(promises);
+  return { files, media };
+}
+
+// src/parser/xml-parser.ts
+import { XMLParser } from "fast-xml-parser";
+var ARRAY_TAGS = /* @__PURE__ */ new Set([
+  "sp",
+  "pic",
+  "cxnSp",
+  "grpSp",
+  "graphicFrame",
+  "p",
+  "r",
+  "br",
+  "Relationship",
+  "sldId",
+  "gs",
+  "gridCol",
+  "tr",
+  "tc",
+  "ser",
+  "pt"
+]);
+function createXmlParser() {
+  return new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    removeNSPrefix: true,
+    isArray: (_name, jpath) => {
+      const tag = jpath.split(".").pop() ?? "";
+      return ARRAY_TAGS.has(tag);
+    }
+  });
+}
+function parseXml(xml) {
+  const parser = createXmlParser();
+  return parser.parse(xml);
+}
+
+// src/parser/presentation-parser.ts
+var WARN_PREFIX = "[pptx-glimpse]";
+var DEFAULT_SLIDE_WIDTH = 9144e3;
+var DEFAULT_SLIDE_HEIGHT = 5143500;
+function parsePresentation(xml) {
+  const parsed = parseXml(xml);
+  const pres = parsed.presentation;
+  if (!pres) {
+    console.warn(`${WARN_PREFIX} Presentation: missing root element "presentation" in XML`);
+    return {
+      slideSize: { width: DEFAULT_SLIDE_WIDTH, height: DEFAULT_SLIDE_HEIGHT },
+      slideRIds: []
+    };
+  }
+  const sldSz = pres.sldSz;
+  let slideSize;
+  if (!sldSz || sldSz["@_cx"] === void 0 || sldSz["@_cy"] === void 0) {
+    console.warn(
+      `${WARN_PREFIX} Presentation: sldSz missing, using default ${DEFAULT_SLIDE_WIDTH}x${DEFAULT_SLIDE_HEIGHT} EMU`
+    );
+    slideSize = { width: DEFAULT_SLIDE_WIDTH, height: DEFAULT_SLIDE_HEIGHT };
+  } else {
+    slideSize = {
+      width: Number(sldSz["@_cx"]),
+      height: Number(sldSz["@_cy"])
+    };
+  }
+  const sldIdLst = pres.sldIdLst?.sldId ?? [];
+  const slideRIds = sldIdLst.map((s) => s["@_r:id"] ?? s["@_id"]).filter((id) => {
+    if (id === void 0) {
+      console.warn(
+        `${WARN_PREFIX} Presentation: undefined slide relationship ID found, skipping`
+      );
+      return false;
+    }
+    return true;
+  });
+  return { slideSize, slideRIds };
+}
+
+// src/parser/theme-parser.ts
+var WARN_PREFIX2 = "[pptx-glimpse]";
+function parseTheme(xml) {
+  const parsed = parseXml(xml);
+  if (!parsed.theme) {
+    console.warn(`${WARN_PREFIX2} Theme: missing root element "theme" in XML`);
+    return {
+      colorScheme: defaultColorScheme(),
+      fontScheme: {
+        majorFont: "Calibri",
+        minorFont: "Calibri",
+        majorFontEa: null,
+        minorFontEa: null
+      }
+    };
+  }
+  const themeElements = parsed.theme.themeElements;
+  if (!themeElements) {
+    console.warn(`${WARN_PREFIX2} Theme: themeElements not found, using defaults`);
+    return {
+      colorScheme: defaultColorScheme(),
+      fontScheme: {
+        majorFont: "Calibri",
+        minorFont: "Calibri",
+        majorFontEa: null,
+        minorFontEa: null
+      }
+    };
+  }
+  if (!themeElements.clrScheme) {
+    console.warn(`${WARN_PREFIX2} Theme: colorScheme not found, using defaults`);
+  }
+  if (!themeElements.fontScheme) {
+    console.warn(`${WARN_PREFIX2} Theme: fontScheme not found, using defaults`);
+  }
+  const colorScheme = parseColorScheme(themeElements.clrScheme);
+  const fontScheme = parseFontScheme(themeElements.fontScheme);
+  return { colorScheme, fontScheme };
+}
+function parseColorScheme(clrScheme) {
+  if (!clrScheme) return defaultColorScheme();
+  return {
+    dk1: extractColor(clrScheme.dk1),
+    lt1: extractColor(clrScheme.lt1),
+    dk2: extractColor(clrScheme.dk2),
+    lt2: extractColor(clrScheme.lt2),
+    accent1: extractColor(clrScheme.accent1),
+    accent2: extractColor(clrScheme.accent2),
+    accent3: extractColor(clrScheme.accent3),
+    accent4: extractColor(clrScheme.accent4),
+    accent5: extractColor(clrScheme.accent5),
+    accent6: extractColor(clrScheme.accent6),
+    hlink: extractColor(clrScheme.hlink),
+    folHlink: extractColor(clrScheme.folHlink)
+  };
+}
+function extractColor(colorNode) {
+  if (!colorNode) return "#000000";
+  if (colorNode.srgbClr) {
+    return `#${colorNode.srgbClr["@_val"]}`;
+  }
+  if (colorNode.sysClr) {
+    return `#${colorNode.sysClr["@_lastClr"] ?? "000000"}`;
+  }
+  return "#000000";
+}
+function parseFontScheme(fontScheme) {
+  if (!fontScheme)
+    return { majorFont: "Calibri", minorFont: "Calibri", majorFontEa: null, minorFontEa: null };
+  const majorFont = fontScheme.majorFont?.latin?.["@_typeface"] ?? "Calibri";
+  const minorFont = fontScheme.minorFont?.latin?.["@_typeface"] ?? "Calibri";
+  const majorFontEa = fontScheme.majorFont?.ea?.["@_typeface"] ?? null;
+  const minorFontEa = fontScheme.minorFont?.ea?.["@_typeface"] ?? null;
+  return { majorFont, minorFont, majorFontEa, minorFontEa };
+}
+function defaultColorScheme() {
+  return {
+    dk1: "#000000",
+    lt1: "#FFFFFF",
+    dk2: "#44546A",
+    lt2: "#E7E6E6",
+    accent1: "#4472C4",
+    accent2: "#ED7D31",
+    accent3: "#A5A5A5",
+    accent4: "#FFC000",
+    accent5: "#5B9BD5",
+    accent6: "#70AD47",
+    hlink: "#0563C1",
+    folHlink: "#954F72"
+  };
+}
+
+// src/parser/relationship-parser.ts
+var WARN_PREFIX3 = "[pptx-glimpse]";
+function parseRelationships(xml) {
+  const parsed = parseXml(xml);
+  const rels = /* @__PURE__ */ new Map();
+  const root = parsed;
+  if (!root?.Relationships) {
+    console.warn(`${WARN_PREFIX3} Relationship: missing root element "Relationships" in XML`);
+    return rels;
+  }
+  const relationships = root.Relationships.Relationship;
+  if (!relationships) return rels;
+  for (const rel of relationships) {
+    const id = rel["@_Id"];
+    const type = rel["@_Type"];
+    const target = rel["@_Target"];
+    if (!id || !type || !target) {
+      console.warn(`${WARN_PREFIX3} Relationship: entry missing required attribute, skipping`);
+      continue;
+    }
+    rels.set(id, { id, type, target });
+  }
+  return rels;
+}
+function buildRelsPath(xmlPath) {
+  const lastSlash = xmlPath.lastIndexOf("/");
+  const dir = xmlPath.substring(0, lastSlash);
+  const filename = xmlPath.substring(lastSlash + 1);
+  return `${dir}/_rels/${filename}.rels`;
+}
+function resolveRelationshipTarget(basePath, relTarget) {
+  if (relTarget.startsWith("/")) {
+    return relTarget.slice(1);
+  }
+  const baseDir = basePath.substring(0, basePath.lastIndexOf("/"));
+  const parts = `${baseDir}/${relTarget}`.split("/");
+  const resolved = [];
+  for (const part of parts) {
+    if (part === "..") {
+      resolved.pop();
+    } else if (part !== ".") {
+      resolved.push(part);
+    }
+  }
+  return resolved.join("/");
+}
+
+// src/parser/fill-parser.ts
+var WARN_PREFIX4 = "[pptx-glimpse]";
+function parseFillFromNode(node, colorResolver, context) {
+  if (!node) return null;
+  if (node.noFill !== void 0) {
+    return { type: "none" };
+  }
+  if (node.solidFill) {
+    const color = colorResolver.resolve(node.solidFill);
+    if (color) {
+      return { type: "solid", color };
+    }
+  }
+  if (node.gradFill) {
+    return parseGradientFill(node.gradFill, colorResolver);
+  }
+  if (node.blipFill && context) {
+    return parseBlipFill(node.blipFill, context);
+  }
+  return null;
+}
+function parseBlipFill(blipFillNode, context) {
+  const rId = blipFillNode?.blip?.["@_r:embed"] ?? blipFillNode?.blip?.["@_embed"];
+  if (!rId) return null;
+  const rel = context.rels.get(rId);
+  if (!rel) return null;
+  const mediaPath = resolveRelationshipTarget(context.basePath, rel.target);
+  const mediaData = context.archive.media.get(mediaPath);
+  if (!mediaData) return null;
+  const ext = mediaPath.split(".").pop()?.toLowerCase() ?? "png";
+  const mimeMap = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    emf: "image/emf",
+    wmf: "image/wmf"
+  };
+  const mimeType = mimeMap[ext] ?? "image/png";
+  const imageData = mediaData.toString("base64");
+  return { type: "image", imageData, mimeType };
+}
+function parseGradientFill(gradNode, colorResolver) {
+  const gsLst = gradNode.gsLst?.gs;
+  if (!gsLst) {
+    console.warn(`${WARN_PREFIX4} GradientFill: gsLst not found, skipping gradient`);
+    return null;
+  }
+  const stops = [];
+  for (const gs of gsLst) {
+    const position = Number(gs["@_pos"] ?? 0) / 1e5;
+    const color = colorResolver.resolve(gs);
+    if (color) {
+      stops.push({ position, color });
+    }
+  }
+  let angle = 0;
+  if (gradNode.lin) {
+    angle = Number(gradNode.lin["@_ang"] ?? 0) / 6e4;
+  }
+  return { type: "gradient", stops, angle };
+}
+function parseOutline(lnNode, colorResolver) {
+  if (!lnNode) return null;
+  const width = Number(lnNode["@_w"] ?? 12700);
+  let fill = null;
+  if (lnNode.solidFill) {
+    const color = colorResolver.resolve(lnNode.solidFill);
+    if (color) {
+      fill = { type: "solid", color };
+    }
+  }
+  if (lnNode.noFill !== void 0) {
+    return null;
+  }
+  const dashStyle = lnNode.prstDash?.["@_val"] ?? "solid";
+  return { width, fill, dashStyle };
+}
+
+// src/parser/effect-parser.ts
+function parseEffectList(effectLstNode, colorResolver) {
+  if (!effectLstNode) return null;
+  const outerShadow = parseOuterShadow(effectLstNode.outerShdw, colorResolver);
+  const innerShadow = parseInnerShadow(effectLstNode.innerShdw, colorResolver);
+  const glow = parseGlow(effectLstNode.glow, colorResolver);
+  const softEdge = parseSoftEdge(effectLstNode.softEdge);
+  if (!outerShadow && !innerShadow && !glow && !softEdge) {
+    return null;
+  }
+  return { outerShadow, innerShadow, glow, softEdge };
+}
+function parseOuterShadow(node, colorResolver) {
+  if (!node) return null;
+  const color = colorResolver.resolve(node);
+  if (!color) return null;
+  return {
+    blurRadius: Number(node["@_blurRad"] ?? 0),
+    distance: Number(node["@_dist"] ?? 0),
+    direction: Number(node["@_dir"] ?? 0) / 6e4,
+    color,
+    alignment: node["@_algn"] ?? "b",
+    rotateWithShape: node["@_rotWithShape"] !== "0"
+  };
+}
+function parseInnerShadow(node, colorResolver) {
+  if (!node) return null;
+  const color = colorResolver.resolve(node);
+  if (!color) return null;
+  return {
+    blurRadius: Number(node["@_blurRad"] ?? 0),
+    distance: Number(node["@_dist"] ?? 0),
+    direction: Number(node["@_dir"] ?? 0) / 6e4,
+    color
+  };
+}
+function parseGlow(node, colorResolver) {
+  if (!node) return null;
+  const color = colorResolver.resolve(node);
+  if (!color) return null;
+  return {
+    radius: Number(node["@_rad"] ?? 0),
+    color
+  };
+}
+function parseSoftEdge(node) {
+  if (!node) return null;
+  return {
+    radius: Number(node["@_rad"] ?? 0)
+  };
+}
+
+// src/parser/chart-parser.ts
+var ACCENT_KEYS = ["accent1", "accent2", "accent3", "accent4", "accent5", "accent6"];
+var CHART_TYPE_MAP = [
+  ["barChart", "bar"],
+  ["bar3DChart", "bar"],
+  ["lineChart", "line"],
+  ["line3DChart", "line"],
+  ["pieChart", "pie"],
+  ["pie3DChart", "pie"],
+  ["doughnutChart", "pie"],
+  ["scatterChart", "scatter"]
+];
+function parseChart(chartXml, colorResolver) {
+  const parsed = parseXml(chartXml);
+  const chartSpace = parsed.chartSpace;
+  if (!chartSpace) return null;
+  const chart = chartSpace.chart;
+  if (!chart) return null;
+  const plotArea = chart.plotArea;
+  if (!plotArea) return null;
+  const title = parseChartTitle(chart.title);
+  const { chartType, series, categories, barDirection } = parseChartTypeAndData(
+    plotArea,
+    colorResolver
+  );
+  if (!chartType) return null;
+  const legend = parseLegend(chart.legend);
+  return {
+    chartType,
+    title,
+    series,
+    categories,
+    ...barDirection !== void 0 && { barDirection },
+    legend
+  };
+}
+function parseChartTypeAndData(plotArea, colorResolver) {
+  for (const [xmlTag, chartType] of CHART_TYPE_MAP) {
+    const chartNode = plotArea[xmlTag];
+    if (!chartNode) continue;
+    const serList = chartNode.ser ?? [];
+    const series = serList.map(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (ser, index) => parseSeries(ser, chartType, index, colorResolver)
+    );
+    const categories = extractCategories(serList);
+    const barDirection = chartType === "bar" ? chartNode.barDir?.["@_val"] ?? "col" : void 0;
+    return { chartType, series, categories, barDirection };
+  }
+  return { chartType: null, series: [], categories: [] };
+}
+function parseSeries(ser, chartType, seriesIndex, colorResolver) {
+  const name = parseSeriesName(ser.tx);
+  const values = parseNumericData(chartType === "scatter" ? ser.yVal : ser.val);
+  const xValues = chartType === "scatter" ? parseNumericData(ser.xVal) : void 0;
+  const color = resolveSeriesColor(ser.spPr, seriesIndex, colorResolver);
+  return {
+    name,
+    values,
+    ...xValues !== void 0 && { xValues },
+    color
+  };
+}
+function parseSeriesName(tx) {
+  if (!tx) return null;
+  const strCache = tx.strRef?.strCache;
+  if (strCache?.pt) {
+    const pts = strCache.pt;
+    return pts[0]?.v ?? null;
+  }
+  if (typeof tx.v === "string") return tx.v;
+  return null;
+}
+function parseNumericData(valNode) {
+  if (!valNode) return [];
+  const numCache = valNode.numRef?.numCache;
+  if (!numCache?.pt) return [];
+  const pts = numCache.pt;
+  return pts.slice().sort((a, b) => Number(a["@_idx"]) - Number(b["@_idx"])).map((pt) => Number(pt.v ?? 0));
+}
+function extractCategories(serList) {
+  for (const ser of serList) {
+    const cat = ser.cat;
+    if (!cat) continue;
+    const strCache = cat.strRef?.strCache ?? cat.numRef?.numCache;
+    if (strCache?.pt) {
+      return strCache.pt.slice().sort((a, b) => Number(a["@_idx"]) - Number(b["@_idx"])).map((pt) => String(pt.v ?? ""));
+    }
+  }
+  return [];
+}
+function resolveSeriesColor(spPr, seriesIndex, colorResolver) {
+  if (spPr) {
+    const resolved2 = colorResolver.resolve(spPr.solidFill ?? spPr);
+    if (resolved2) return resolved2;
+  }
+  const accentKey = ACCENT_KEYS[seriesIndex % ACCENT_KEYS.length];
+  const resolved = colorResolver.resolve({ schemeClr: { "@_val": accentKey } });
+  return resolved ?? { hex: "#4472C4", alpha: 1 };
+}
+function parseChartTitle(titleNode) {
+  if (!titleNode) return null;
+  const rich = titleNode.tx?.rich;
+  if (!rich?.p) return null;
+  const pList = Array.isArray(rich.p) ? rich.p : [rich.p];
+  const texts = [];
+  for (const p of pList) {
+    const rList = p.r ?? [];
+    for (const r of rList) {
+      const t = r.t;
+      if (typeof t === "string") texts.push(t);
+      else if (t?.["#text"]) texts.push(String(t["#text"]));
+    }
+  }
+  return texts.length > 0 ? texts.join("") : null;
+}
+function parseLegend(legendNode) {
+  if (!legendNode) return null;
+  const pos = legendNode.legendPos?.["@_val"] ?? "b";
+  return { position: pos };
+}
+
+// src/parser/table-parser.ts
+function parseTable(tblNode, colorResolver) {
+  if (!tblNode) return null;
+  const columns = parseColumns(tblNode.tblGrid);
+  if (columns.length === 0) return null;
+  const rows = parseRows(tblNode.tr, colorResolver);
+  return { rows, columns };
+}
+function parseColumns(tblGrid) {
+  if (!tblGrid) return [];
+  const gridCols = tblGrid.gridCol ?? [];
+  return gridCols.map((col) => ({
+    width: Number(col["@_w"] ?? 0)
+  }));
+}
+function parseRows(trList, colorResolver) {
+  if (!trList) return [];
+  const rows = [];
+  for (const tr of trList) {
+    const height = Number(tr["@_h"] ?? 0);
+    const cells = parseCells(tr.tc, colorResolver);
+    rows.push({ height, cells });
+  }
+  return rows;
+}
+function parseCells(tcList, colorResolver) {
+  if (!tcList) return [];
+  const cells = [];
+  for (const tc of tcList) {
+    const textBody = parseTextBody(tc.txBody, colorResolver);
+    const tcPr = tc.tcPr;
+    const fill = tcPr ? parseFillFromNode(tcPr, colorResolver) : null;
+    const borders = tcPr ? parseCellBorders(tcPr, colorResolver) : null;
+    const gridSpan = Number(tc["@_gridSpan"] ?? 1);
+    const rowSpan = Number(tc["@_rowSpan"] ?? 1);
+    const hMerge = tcPr?.["@_hMerge"] === "1" || tcPr?.["@_hMerge"] === "true";
+    const vMerge = tcPr?.["@_vMerge"] === "1" || tcPr?.["@_vMerge"] === "true";
+    cells.push({ textBody, fill, borders, gridSpan, rowSpan, hMerge, vMerge });
+  }
+  return cells;
+}
+function parseCellBorders(tcPr, colorResolver) {
+  const top = parseOutline(tcPr.lnT, colorResolver);
+  const bottom = parseOutline(tcPr.lnB, colorResolver);
+  const left = parseOutline(tcPr.lnL, colorResolver);
+  const right = parseOutline(tcPr.lnR, colorResolver);
+  if (!top && !bottom && !left && !right) return null;
+  return { top, bottom, left, right };
+}
+
+// src/utils/constants.ts
+var EMU_PER_INCH = 914400;
+var DEFAULT_DPI = 96;
+var DEFAULT_OUTPUT_WIDTH = 960;
+
+// src/utils/emu.ts
+function emuToPixels(emu, dpi = DEFAULT_DPI) {
+  return emu / EMU_PER_INCH * dpi;
+}
+function hundredthPointToPoint(value) {
+  return value / 100;
+}
+
+// src/parser/slide-parser.ts
+var WARN_PREFIX5 = "[pptx-glimpse]";
+function parseSlide(slideXml, slidePath, slideNumber, archive, colorResolver) {
+  const parsed = parseXml(slideXml);
+  const sld = parsed.sld;
+  if (!sld) {
+    console.warn(`${WARN_PREFIX5} Slide ${slideNumber}: missing root element "sld" in XML`);
+  }
+  const relsPath = slidePath.replace("ppt/slides/", "ppt/slides/_rels/") + ".rels";
+  const relsXml = archive.files.get(relsPath);
+  const rels = relsXml ? parseRelationships(relsXml) : /* @__PURE__ */ new Map();
+  const fillContext = { rels, archive, basePath: slidePath };
+  const background = parseBackground(sld?.cSld?.bg, colorResolver, fillContext);
+  const elements = parseShapeTree(
+    sld?.cSld?.spTree,
+    rels,
+    slidePath,
+    archive,
+    colorResolver,
+    `Slide ${slideNumber}`
+  );
+  return { slideNumber, background, elements };
+}
+function parseBackground(bgNode, colorResolver, context) {
+  if (!bgNode) return null;
+  const bgPr = bgNode.bgPr;
+  if (!bgPr) return null;
+  const fill = parseFillFromNode(bgPr, colorResolver, context);
+  return { fill };
+}
+function parseShapeTree(spTree, rels, slidePath, archive, colorResolver, context) {
+  if (!spTree) return [];
+  const ctx = context ?? slidePath;
+  const elements = [];
+  const shapes = spTree.sp ?? [];
+  for (const sp of shapes) {
+    const shape = parseShape(sp, colorResolver);
+    if (shape) {
+      elements.push(shape);
+    } else {
+      console.warn(`${WARN_PREFIX5} ${ctx}: shape skipped (parse returned null)`);
+    }
+  }
+  const pics = spTree.pic ?? [];
+  for (const pic of pics) {
+    const img = parseImage(pic, rels, slidePath, archive, colorResolver);
+    if (img) {
+      elements.push(img);
+    } else {
+      console.warn(`${WARN_PREFIX5} ${ctx}: image skipped (parse returned null)`);
+    }
+  }
+  const cxnSps = spTree.cxnSp ?? [];
+  for (const cxn of cxnSps) {
+    const connector = parseConnector(cxn, colorResolver);
+    if (connector) {
+      elements.push(connector);
+    } else {
+      console.warn(`${WARN_PREFIX5} ${ctx}: connector skipped (parse returned null)`);
+    }
+  }
+  const grpSps = spTree.grpSp ?? [];
+  for (const grp of grpSps) {
+    const group = parseGroup(grp, rels, slidePath, archive, colorResolver);
+    if (group) {
+      elements.push(group);
+    } else {
+      console.warn(`${WARN_PREFIX5} ${ctx}: group skipped (parse returned null)`);
+    }
+  }
+  const graphicFrames = spTree.graphicFrame ?? [];
+  for (const gf of graphicFrames) {
+    const chart = parseGraphicFrame(gf, rels, slidePath, archive, colorResolver);
+    if (chart) {
+      elements.push(chart);
+    } else {
+      console.warn(`${WARN_PREFIX5} ${ctx}: graphicFrame skipped (parse returned null)`);
+    }
+  }
+  return elements;
+}
+function parseShape(sp, colorResolver) {
+  const spPr = sp.spPr;
+  if (!spPr) return null;
+  const transform = parseTransform(spPr.xfrm);
+  if (!transform) return null;
+  const geometry = parseGeometry(spPr);
+  const fill = parseFillFromNode(spPr, colorResolver);
+  const outline = parseOutline(spPr.ln, colorResolver);
+  const textBody = parseTextBody(sp.txBody, colorResolver);
+  const effects = parseEffectList(spPr.effectLst, colorResolver);
+  const ph = sp.nvSpPr?.nvPr?.ph;
+  const placeholderType = ph ? ph["@_type"] ?? "body" : void 0;
+  const placeholderIdx = ph?.["@_idx"] !== void 0 ? Number(ph["@_idx"]) : void 0;
+  return {
+    type: "shape",
+    transform,
+    geometry,
+    fill,
+    outline,
+    textBody,
+    effects,
+    ...placeholderType !== void 0 && { placeholderType },
+    ...placeholderIdx !== void 0 && { placeholderIdx }
+  };
+}
+function parseImage(pic, rels, slidePath, archive, colorResolver) {
+  const spPr = pic.spPr;
+  if (!spPr) return null;
+  const transform = parseTransform(spPr.xfrm);
+  if (!transform) return null;
+  const blipFill = pic.blipFill;
+  const rId = blipFill?.blip?.["@_r:embed"] ?? blipFill?.blip?.["@_embed"];
+  if (!rId) return null;
+  const rel = rels.get(rId);
+  if (!rel) return null;
+  const mediaPath = resolveRelationshipTarget(slidePath, rel.target);
+  const mediaData = archive.media.get(mediaPath);
+  if (!mediaData) return null;
+  const ext = mediaPath.split(".").pop()?.toLowerCase() ?? "png";
+  const mimeMap = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    emf: "image/emf",
+    wmf: "image/wmf"
+  };
+  const mimeType = mimeMap[ext] ?? "image/png";
+  const imageData = mediaData.toString("base64");
+  const effects = parseEffectList(spPr.effectLst, colorResolver);
+  return {
+    type: "image",
+    transform,
+    imageData,
+    mimeType,
+    effects
+  };
+}
+function parseConnector(cxn, colorResolver) {
+  const spPr = cxn.spPr;
+  if (!spPr) return null;
+  const transform = parseTransform(spPr.xfrm);
+  if (!transform) return null;
+  const outline = parseOutline(spPr.ln, colorResolver);
+  const effects = parseEffectList(spPr.effectLst, colorResolver);
+  return { type: "connector", transform, outline, effects };
+}
+function parseGroup(grp, rels, slidePath, archive, colorResolver) {
+  const grpSpPr = grp.grpSpPr;
+  if (!grpSpPr) return null;
+  const transform = parseTransform(grpSpPr.xfrm);
+  if (!transform) return null;
+  const childOff = grpSpPr.xfrm?.chOff;
+  const childExt = grpSpPr.xfrm?.chExt;
+  const childTransform = {
+    offsetX: Number(childOff?.["@_x"] ?? 0),
+    offsetY: Number(childOff?.["@_y"] ?? 0),
+    extentWidth: Number(childExt?.["@_cx"] ?? transform.extentWidth),
+    extentHeight: Number(childExt?.["@_cy"] ?? transform.extentHeight),
+    rotation: 0,
+    flipH: false,
+    flipV: false
+  };
+  const children = parseShapeTree(grp, rels, slidePath, archive, colorResolver);
+  const effects = parseEffectList(grpSpPr.effectLst, colorResolver);
+  return { type: "group", transform, childTransform, children, effects };
+}
+function parseGraphicFrame(gf, rels, slidePath, archive, colorResolver) {
+  const xfrm = gf.xfrm;
+  const transform = parseTransform(xfrm);
+  if (!transform) return null;
+  const graphicData = gf.graphic?.graphicData;
+  if (!graphicData) return null;
+  const chartRef = graphicData.chart;
+  if (chartRef) {
+    const rId = chartRef["@_r:id"] ?? chartRef["@_id"];
+    if (!rId) return null;
+    const rel = rels.get(rId);
+    if (!rel) return null;
+    const chartPath = resolveRelationshipTarget(slidePath, rel.target);
+    const chartXml = archive.files.get(chartPath);
+    if (!chartXml) return null;
+    const chartData = parseChart(chartXml, colorResolver);
+    if (!chartData) return null;
+    return { type: "chart", transform, chart: chartData };
+  }
+  const tblNode = graphicData.tbl;
+  if (tblNode) {
+    const tableData = parseTable(tblNode, colorResolver);
+    if (!tableData) return null;
+    return { type: "table", transform, table: tableData };
+  }
+  return null;
+}
+function parseTransform(xfrm) {
+  if (!xfrm) return null;
+  const off = xfrm.off;
+  const ext = xfrm.ext;
+  if (!off || !ext) return null;
+  let offsetX = Number(off["@_x"] ?? 0);
+  let offsetY = Number(off["@_y"] ?? 0);
+  let extentWidth = Number(ext["@_cx"] ?? 0);
+  let extentHeight = Number(ext["@_cy"] ?? 0);
+  let rotation = Number(xfrm["@_rot"] ?? 0);
+  if (Number.isNaN(offsetX)) {
+    console.warn(`${WARN_PREFIX5} NaN detected in transform offsetX, defaulting to 0`);
+    offsetX = 0;
+  }
+  if (Number.isNaN(offsetY)) {
+    console.warn(`${WARN_PREFIX5} NaN detected in transform offsetY, defaulting to 0`);
+    offsetY = 0;
+  }
+  if (Number.isNaN(extentWidth)) {
+    console.warn(`${WARN_PREFIX5} NaN detected in transform extentWidth, defaulting to 0`);
+    extentWidth = 0;
+  }
+  if (Number.isNaN(extentHeight)) {
+    console.warn(`${WARN_PREFIX5} NaN detected in transform extentHeight, defaulting to 0`);
+    extentHeight = 0;
+  }
+  if (Number.isNaN(rotation)) {
+    console.warn(`${WARN_PREFIX5} NaN detected in transform rotation, defaulting to 0`);
+    rotation = 0;
+  }
+  return {
+    offsetX,
+    offsetY,
+    extentWidth,
+    extentHeight,
+    rotation: rotation / 6e4,
+    flipH: xfrm["@_flipH"] === "1" || xfrm["@_flipH"] === "true",
+    flipV: xfrm["@_flipV"] === "1" || xfrm["@_flipV"] === "true"
+  };
+}
+function parseGeometry(spPr) {
+  if (spPr.prstGeom) {
+    const preset = spPr.prstGeom["@_prst"] ?? "rect";
+    const avLst = spPr.prstGeom.avLst;
+    const adjustValues = {};
+    if (avLst?.gd) {
+      const guides = Array.isArray(avLst.gd) ? avLst.gd : [avLst.gd];
+      for (const gd of guides) {
+        const name = gd["@_name"];
+        const fmla = gd["@_fmla"];
+        const match = fmla?.match(/val\s+(\d+)/);
+        if (name && match) {
+          adjustValues[name] = Number(match[1]);
+        }
+      }
+    }
+    return { type: "preset", preset, adjustValues };
+  }
+  if (spPr.custGeom) {
+    const pathData = parseCustomGeometryPaths(spPr.custGeom);
+    if (pathData) {
+      return { type: "custom", pathData };
+    }
+  }
+  return { type: "preset", preset: "rect", adjustValues: {} };
+}
+function parseCustomGeometryPaths(custGeom) {
+  const pathLst = custGeom.pathLst;
+  if (!pathLst?.path) return null;
+  const paths = Array.isArray(pathLst.path) ? pathLst.path : [pathLst.path];
+  const svgParts = [];
+  for (const path of paths) {
+    const w = Number(path["@_w"] ?? 0);
+    const h = Number(path["@_h"] ?? 0);
+    if (w === 0 && h === 0) continue;
+    const processCommands = (commands, prefix) => {
+      if (!commands) return;
+      const list = Array.isArray(commands) ? commands : [commands];
+      for (const cmd of list) {
+        if (prefix === "M" || prefix === "L") {
+          const pt = cmd.pt;
+          if (pt) {
+            const pts = Array.isArray(pt) ? pt : [pt];
+            svgParts.push(
+              `${prefix} ${pts.map((p) => `${p["@_x"]} ${p["@_y"]}`).join(" ")}`
+            );
+          }
+        }
+      }
+    };
+    if (path.moveTo) processCommands(Array.isArray(path.moveTo) ? path.moveTo : [path.moveTo], "M");
+    if (path.lnTo) processCommands(Array.isArray(path.lnTo) ? path.lnTo : [path.lnTo], "L");
+    if (path.cubicBezTo) {
+      const bezList = Array.isArray(path.cubicBezTo) ? path.cubicBezTo : [path.cubicBezTo];
+      for (const bez of bezList) {
+        const pts = Array.isArray(bez.pt) ? bez.pt : [bez.pt];
+        if (pts.length >= 3) {
+          svgParts.push(
+            `C ${pts.map((p) => `${p["@_x"]} ${p["@_y"]}`).join(", ")}`
+          );
+        }
+      }
+    }
+    if (path.close !== void 0) {
+      svgParts.push("Z");
+    }
+  }
+  return svgParts.length > 0 ? svgParts.join(" ") : null;
+}
+function parseTextBody(txBody, colorResolver) {
+  if (!txBody) return null;
+  const bodyPr = txBody.bodyPr;
+  let autoFit = "noAutofit";
+  let fontScale = 1;
+  let lnSpcReduction = 0;
+  if (bodyPr?.normAutofit !== void 0) {
+    autoFit = "normAutofit";
+    const normAutofit = bodyPr.normAutofit;
+    if (typeof normAutofit === "object" && normAutofit !== null) {
+      fontScale = normAutofit["@_fontScale"] ? Number(normAutofit["@_fontScale"]) / 1e5 : 1;
+      lnSpcReduction = normAutofit["@_lnSpcReduction"] ? Number(normAutofit["@_lnSpcReduction"]) / 1e5 : 0;
+    }
+  } else if (bodyPr?.spAutoFit !== void 0) {
+    autoFit = "spAutofit";
+  }
+  const bodyProperties = {
+    anchor: bodyPr?.["@_anchor"] ?? "t",
+    marginLeft: Number(bodyPr?.["@_lIns"] ?? 91440),
+    marginRight: Number(bodyPr?.["@_rIns"] ?? 91440),
+    marginTop: Number(bodyPr?.["@_tIns"] ?? 45720),
+    marginBottom: Number(bodyPr?.["@_bIns"] ?? 45720),
+    wrap: bodyPr?.["@_wrap"] ?? "square",
+    autoFit,
+    fontScale,
+    lnSpcReduction
+  };
+  const paragraphs = [];
+  const pList = txBody.p ?? [];
+  for (const p of pList) {
+    paragraphs.push(parseParagraph(p, colorResolver));
+  }
+  if (paragraphs.length === 0) return null;
+  return { paragraphs, bodyProperties };
+}
+var VALID_AUTO_NUM_SCHEMES = /* @__PURE__ */ new Set([
+  "arabicPeriod",
+  "arabicParenR",
+  "romanUcPeriod",
+  "romanLcPeriod",
+  "alphaUcPeriod",
+  "alphaLcPeriod",
+  "alphaLcParenR",
+  "alphaUcParenR",
+  "arabicPlain"
+]);
+function parseBullet(pPr, colorResolver) {
+  let bullet = null;
+  let bulletFont = null;
+  let bulletColor = colorResolver.resolve(pPr?.buClr);
+  if (!pPr?.buClr) bulletColor = null;
+  const bulletSizePct = pPr?.buSzPct ? Number(pPr.buSzPct["@_val"]) : null;
+  if (pPr?.buNone !== void 0) {
+    bullet = { type: "none" };
+  } else if (pPr?.buChar) {
+    bullet = { type: "char", char: pPr.buChar["@_char"] ?? "\u2022" };
+  } else if (pPr?.buAutoNum) {
+    const scheme = pPr.buAutoNum["@_type"] ?? "arabicPeriod";
+    bullet = {
+      type: "autoNum",
+      scheme: VALID_AUTO_NUM_SCHEMES.has(scheme) ? scheme : "arabicPeriod",
+      startAt: Number(pPr.buAutoNum["@_startAt"] ?? 1)
+    };
+  }
+  if (pPr?.buFont) {
+    bulletFont = pPr.buFont["@_typeface"] ?? null;
+  }
+  return { bullet, bulletFont, bulletColor, bulletSizePct };
+}
+function parseParagraph(p, colorResolver) {
+  const pPr = p.pPr;
+  const { bullet, bulletFont, bulletColor, bulletSizePct } = parseBullet(pPr, colorResolver);
+  const properties = {
+    alignment: pPr?.["@_algn"] ?? "l",
+    lineSpacing: pPr?.lnSpc?.spcPct ? Number(pPr.lnSpc.spcPct["@_val"]) : null,
+    spaceBefore: pPr?.spcBef?.spcPts ? Number(pPr.spcBef.spcPts["@_val"]) : 0,
+    spaceAfter: pPr?.spcAft?.spcPts ? Number(pPr.spcAft.spcPts["@_val"]) : 0,
+    level: Number(pPr?.["@_lvl"] ?? 0),
+    bullet,
+    bulletFont,
+    bulletColor,
+    bulletSizePct,
+    marginLeft: Number(pPr?.["@_marL"] ?? 0),
+    indent: Number(pPr?.["@_indent"] ?? 0)
+  };
+  const runs = [];
+  const rList = p.r ?? [];
+  for (const r of rList) {
+    const text = r.t ?? "";
+    const textContent = typeof text === "object" ? text["#text"] ?? "" : String(text);
+    const rPr = r.rPr;
+    const runProps = parseRunProperties(rPr, colorResolver);
+    runs.push({ text: textContent, properties: runProps });
+  }
+  return { runs, properties };
+}
+function parseRunProperties(rPr, colorResolver) {
+  if (!rPr) {
+    return {
+      fontSize: null,
+      fontFamily: null,
+      fontFamilyEa: null,
+      bold: false,
+      italic: false,
+      underline: false,
+      strikethrough: false,
+      color: null,
+      baseline: 0
+    };
+  }
+  const fontSize = rPr["@_sz"] ? hundredthPointToPoint(Number(rPr["@_sz"])) : null;
+  const fontFamily = rPr.latin?.["@_typeface"] ?? null;
+  const fontFamilyEa = rPr.ea?.["@_typeface"] ?? null;
+  const bold = rPr["@_b"] === "1" || rPr["@_b"] === "true";
+  const italic = rPr["@_i"] === "1" || rPr["@_i"] === "true";
+  const underline = rPr["@_u"] !== void 0 && rPr["@_u"] !== "none";
+  const strikethrough = rPr["@_strike"] !== void 0 && rPr["@_strike"] !== "noStrike";
+  const baseline = rPr["@_baseline"] ? Number(rPr["@_baseline"]) / 1e3 : 0;
+  let color = colorResolver.resolve(rPr.solidFill ?? rPr);
+  if (!rPr.solidFill && !rPr.srgbClr && !rPr.schemeClr && !rPr.sysClr) {
+    color = null;
+  }
+  return {
+    fontSize,
+    fontFamily,
+    fontFamilyEa,
+    bold,
+    italic,
+    underline,
+    strikethrough,
+    color,
+    baseline
+  };
+}
+
+// src/parser/slide-master-parser.ts
+var WARN_PREFIX6 = "[pptx-glimpse]";
+var DEFAULT_COLOR_MAP = {
+  bg1: "lt1",
+  tx1: "dk1",
+  bg2: "lt2",
+  tx2: "dk2",
+  accent1: "accent1",
+  accent2: "accent2",
+  accent3: "accent3",
+  accent4: "accent4",
+  accent5: "accent5",
+  accent6: "accent6",
+  hlink: "hlink",
+  folHlink: "folHlink"
+};
+function parseSlideMasterColorMap(xml) {
+  const parsed = parseXml(xml);
+  if (!parsed.sldMaster) {
+    console.warn(`${WARN_PREFIX6} SlideMaster: missing root element "sldMaster" in XML`);
+    return { ...DEFAULT_COLOR_MAP };
+  }
+  const clrMap = parsed.sldMaster.clrMap;
+  if (!clrMap) return { ...DEFAULT_COLOR_MAP };
+  const result = {};
+  for (const key of Object.keys(DEFAULT_COLOR_MAP)) {
+    const val = clrMap[`@_${key}`];
+    result[key] = val ?? DEFAULT_COLOR_MAP[key];
+  }
+  return result;
+}
+function parseSlideMasterBackground(xml, colorResolver, context) {
+  const parsed = parseXml(xml);
+  if (!parsed.sldMaster) {
+    console.warn(`${WARN_PREFIX6} SlideMaster: missing root element "sldMaster" in XML`);
+    return null;
+  }
+  const bg = parsed.sldMaster.cSld?.bg;
+  if (!bg) return null;
+  const bgPr = bg.bgPr;
+  if (!bgPr) return null;
+  const fill = parseFillFromNode(bgPr, colorResolver, context);
+  return { fill };
+}
+function parseSlideMasterElements(xml, masterPath, archive, colorResolver) {
+  const parsed = parseXml(xml);
+  if (!parsed.sldMaster) {
+    console.warn(`${WARN_PREFIX6} SlideMaster: missing root element "sldMaster" in XML`);
+    return [];
+  }
+  const spTree = parsed.sldMaster.cSld?.spTree;
+  if (!spTree) return [];
+  const relsPath = buildRelsPath(masterPath);
+  const relsXml = archive.files.get(relsPath);
+  const rels = relsXml ? parseRelationships(relsXml) : /* @__PURE__ */ new Map();
+  return parseShapeTree(spTree, rels, masterPath, archive, colorResolver);
+}
+
+// src/parser/slide-layout-parser.ts
+var WARN_PREFIX7 = "[pptx-glimpse]";
+function parseSlideLayoutBackground(xml, colorResolver, context) {
+  const parsed = parseXml(xml);
+  if (!parsed.sldLayout) {
+    console.warn(`${WARN_PREFIX7} SlideLayout: missing root element "sldLayout" in XML`);
+    return null;
+  }
+  const bg = parsed.sldLayout.cSld?.bg;
+  if (!bg) return null;
+  const bgPr = bg.bgPr;
+  if (!bgPr) return null;
+  const fill = parseFillFromNode(bgPr, colorResolver, context);
+  return { fill };
+}
+function parseSlideLayoutElements(xml, layoutPath, archive, colorResolver) {
+  const parsed = parseXml(xml);
+  if (!parsed.sldLayout) {
+    console.warn(`${WARN_PREFIX7} SlideLayout: missing root element "sldLayout" in XML`);
+    return [];
+  }
+  const spTree = parsed.sldLayout.cSld?.spTree;
+  if (!spTree) return [];
+  const relsPath = buildRelsPath(layoutPath);
+  const relsXml = archive.files.get(relsPath);
+  const rels = relsXml ? parseRelationships(relsXml) : /* @__PURE__ */ new Map();
+  return parseShapeTree(spTree, rels, layoutPath, archive, colorResolver);
+}
+
+// src/color/color-transforms.ts
+function applyColorTransforms(color, node) {
+  let { hex, alpha } = color;
+  if (node.lumMod || node.lumOff) {
+    hex = applyLuminance(hex, node.lumMod?.["@_val"], node.lumOff?.["@_val"]);
+  }
+  if (node.tint) {
+    hex = applyTint(hex, Number(node.tint["@_val"]) / 1e5);
+  }
+  if (node.shade) {
+    hex = applyShade(hex, Number(node.shade["@_val"]) / 1e5);
+  }
+  if (node.alpha) {
+    alpha = Number(node.alpha["@_val"]) / 1e5;
+  }
+  return { hex, alpha };
+}
+function applyLuminance(hex, lumModVal, lumOffVal) {
+  const { h, s, l } = hexToHsl(hex);
+  const lumMod = lumModVal ? Number(lumModVal) / 1e5 : 1;
+  const lumOff = lumOffVal ? Number(lumOffVal) / 1e5 : 0;
+  const newL = Math.min(1, Math.max(0, l * lumMod + lumOff));
+  return hslToHex(h, s, newL);
+}
+function applyTint(hex, tintAmount) {
+  const { r, g, b } = hexToRgb(hex);
+  const newR = Math.round(r + (255 - r) * tintAmount);
+  const newG = Math.round(g + (255 - g) * tintAmount);
+  const newB = Math.round(b + (255 - b) * tintAmount);
+  return rgbToHex(newR, newG, newB);
+}
+function applyShade(hex, shadeAmount) {
+  const { r, g, b } = hexToRgb(hex);
+  const newR = Math.round(r * shadeAmount);
+  const newG = Math.round(g * shadeAmount);
+  const newB = Math.round(b * shadeAmount);
+  return rgbToHex(newR, newG, newB);
+}
+function hexToRgb(hex) {
+  const h = hex.replace("#", "");
+  return {
+    r: parseInt(h.substring(0, 2), 16),
+    g: parseInt(h.substring(2, 4), 16),
+    b: parseInt(h.substring(4, 6), 16)
+  };
+}
+function rgbToHex(r, g, b) {
+  const toHex = (n) => Math.min(255, Math.max(0, n)).toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function hexToHsl(hex) {
+  const { r: r255, g: g255, b: b255 } = hexToRgb(hex);
+  const r = r255 / 255;
+  const g = g255 / 255;
+  const b = b255 / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) {
+    return { h: 0, s: 0, l };
+  }
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h;
+  if (max === r) {
+    h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+  } else if (max === g) {
+    h = ((b - r) / d + 2) / 6;
+  } else {
+    h = ((r - g) / d + 4) / 6;
+  }
+  return { h, s, l };
+}
+function hslToHex(h, s, l) {
+  if (s === 0) {
+    const v = Math.round(l * 255);
+    return rgbToHex(v, v, v);
+  }
+  const hue2rgb = (p2, q2, t) => {
+    let tt = t;
+    if (tt < 0) tt += 1;
+    if (tt > 1) tt -= 1;
+    if (tt < 1 / 6) return p2 + (q2 - p2) * 6 * tt;
+    if (tt < 1 / 2) return q2;
+    if (tt < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - tt) * 6;
+    return p2;
+  };
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const r = Math.round(hue2rgb(p, q, h + 1 / 3) * 255);
+  const g = Math.round(hue2rgb(p, q, h) * 255);
+  const b = Math.round(hue2rgb(p, q, h - 1 / 3) * 255);
+  return rgbToHex(r, g, b);
+}
+
+// src/color/color-resolver.ts
+var WARN_PREFIX8 = "[pptx-glimpse]";
+var ColorResolver = class {
+  constructor(colorScheme, colorMap) {
+    this.colorScheme = colorScheme;
+    this.colorMap = colorMap;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolve(colorNode) {
+    if (!colorNode) return null;
+    if (colorNode.srgbClr) {
+      return this.resolveSrgbClr(colorNode.srgbClr);
+    }
+    if (colorNode.schemeClr) {
+      return this.resolveSchemeClr(colorNode.schemeClr);
+    }
+    if (colorNode.sysClr) {
+      return this.resolveSysClr(colorNode.sysClr);
+    }
+    const keys = Object.keys(colorNode).filter((k) => !k.startsWith("@_"));
+    if (keys.length > 0) {
+      console.warn(
+        `${WARN_PREFIX8} ColorResolver: unknown color node structure [${keys.join(", ")}]`
+      );
+    }
+    return null;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolveSrgbClr(node) {
+    const hex = `#${node["@_val"]}`;
+    const alpha = extractAlpha(node);
+    return applyColorTransforms({ hex, alpha }, node);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolveSchemeClr(node) {
+    const schemeName = node["@_val"];
+    const hex = this.resolveSchemeColorName(schemeName);
+    const alpha = extractAlpha(node);
+    return applyColorTransforms({ hex, alpha }, node);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolveSysClr(node) {
+    const hex = `#${node["@_lastClr"] ?? "000000"}`;
+    const alpha = extractAlpha(node);
+    return applyColorTransforms({ hex, alpha }, node);
+  }
+  resolveSchemeColorName(name) {
+    const mapped = this.mapColorName(name);
+    return this.colorScheme[mapped] ?? "#000000";
+  }
+  mapColorName(name) {
+    if (name in this.colorMap) {
+      return this.colorMap[name];
+    }
+    if (name in this.colorScheme) {
+      return name;
+    }
+    return "dk1";
+  }
+};
+function extractAlpha(node) {
+  const alphaNode = node.alpha;
+  if (alphaNode) {
+    return Number(alphaNode["@_val"]) / 1e5;
+  }
+  return 1;
+}
+
+// src/renderer/geometry/preset-geometries.ts
+function regularPolygon(w, h, sides) {
+  const cx = w / 2;
+  const cy = h / 2;
+  const points = Array.from({ length: sides }, (_, i) => {
+    const angle = Math.PI * 2 * i / sides - Math.PI / 2;
+    return `${cx + cx * Math.cos(angle)},${cy + cy * Math.sin(angle)}`;
+  }).join(" ");
+  return `<polygon points="${points}"/>`;
+}
+function starPolygon(w, h, points, innerRatio) {
+  const cx = w / 2;
+  const cy = h / 2;
+  const coords = [];
+  for (let i = 0; i < points * 2; i++) {
+    const angle = Math.PI * 2 * i / (points * 2) - Math.PI / 2;
+    const r = i % 2 === 0 ? 1 : innerRatio;
+    coords.push(`${cx + cx * r * Math.cos(angle)},${cy + cy * r * Math.sin(angle)}`);
+  }
+  return `<polygon points="${coords.join(" ")}"/>`;
+}
+function ooxmlAngleToRadians(angle60k) {
+  return angle60k / 6e4 * (Math.PI / 180);
+}
+var presetGeometries = {
+  // =====================
+  // Basic shapes (existing)
+  // =====================
+  rect: (w, h) => `<rect width="${w}" height="${h}"/>`,
+  ellipse: (w, h) => `<ellipse cx="${w / 2}" cy="${h / 2}" rx="${w / 2}" ry="${h / 2}"/>`,
+  roundRect: (w, h, adj) => {
+    const r = (adj["adj"] ?? 16667) / 1e5 * Math.min(w, h);
+    return `<rect width="${w}" height="${h}" rx="${r}" ry="${r}"/>`;
+  },
+  triangle: (w, h, adj) => {
+    const topX = (adj["adj"] ?? 5e4) / 1e5 * w;
+    return `<polygon points="${topX},0 ${w},${h} 0,${h}"/>`;
+  },
+  rtTriangle: (w, h) => `<polygon points="0,0 ${w},${h} 0,${h}"/>`,
+  diamond: (w, h) => `<polygon points="${w / 2},0 ${w},${h / 2} ${w / 2},${h} 0,${h / 2}"/>`,
+  parallelogram: (w, h, adj) => {
+    const offset = (adj["adj"] ?? 25e3) / 1e5 * w;
+    return `<polygon points="${offset},0 ${w},0 ${w - offset},${h} 0,${h}"/>`;
+  },
+  trapezoid: (w, h, adj) => {
+    const offset = (adj["adj"] ?? 25e3) / 1e5 * w;
+    return `<polygon points="${offset},0 ${w - offset},0 ${w},${h} 0,${h}"/>`;
+  },
+  pentagon: (w, h) => regularPolygon(w, h, 5),
+  hexagon: (w, h, adj) => {
+    const offset = (adj["adj"] ?? 25e3) / 1e5 * w;
+    return `<polygon points="${offset},0 ${w - offset},0 ${w},${h / 2} ${w - offset},${h} ${offset},${h} 0,${h / 2}"/>`;
+  },
+  star4: (w, h) => {
+    const cx = w / 2;
+    const cy = h / 2;
+    const ir = 0.38;
+    return `<polygon points="${cx},0 ${cx + cx * ir},${cy - cy * ir} ${w},${cy} ${cx + cx * ir},${cy + cy * ir} ${cx},${h} ${cx - cx * ir},${cy + cy * ir} 0,${cy} ${cx - cx * ir},${cy - cy * ir}"/>`;
+  },
+  star5: (w, h) => starPolygon(w, h, 5, 0.38),
+  rightArrow: (w, h, adj) => {
+    const headWidth = (adj["adj1"] ?? 5e4) / 1e5 * h;
+    const headLength = (adj["adj2"] ?? 5e4) / 1e5 * w;
+    const bodyTop = (h - headWidth) / 2;
+    const bodyBottom = h - bodyTop;
+    const shaftEnd = w - headLength;
+    return `<polygon points="0,${bodyTop} ${shaftEnd},${bodyTop} ${shaftEnd},0 ${w},${h / 2} ${shaftEnd},${h} ${shaftEnd},${bodyBottom} 0,${bodyBottom}"/>`;
+  },
+  leftArrow: (w, h, adj) => {
+    const headWidth = (adj["adj1"] ?? 5e4) / 1e5 * h;
+    const headLength = (adj["adj2"] ?? 5e4) / 1e5 * w;
+    const bodyTop = (h - headWidth) / 2;
+    const bodyBottom = h - bodyTop;
+    return `<polygon points="${headLength},${bodyTop} ${headLength},0 0,${h / 2} ${headLength},${h} ${headLength},${bodyBottom} ${w},${bodyBottom} ${w},${bodyTop}"/>`;
+  },
+  upArrow: (w, h, adj) => {
+    const headWidth = (adj["adj1"] ?? 5e4) / 1e5 * w;
+    const headLength = (adj["adj2"] ?? 5e4) / 1e5 * h;
+    const bodyLeft = (w - headWidth) / 2;
+    const bodyRight = w - bodyLeft;
+    return `<polygon points="${bodyLeft},${headLength} 0,${headLength} ${w / 2},0 ${w},${headLength} ${bodyRight},${headLength} ${bodyRight},${h} ${bodyLeft},${h}"/>`;
+  },
+  downArrow: (w, h, adj) => {
+    const headWidth = (adj["adj1"] ?? 5e4) / 1e5 * w;
+    const headLength = (adj["adj2"] ?? 5e4) / 1e5 * h;
+    const bodyLeft = (w - headWidth) / 2;
+    const bodyRight = w - bodyLeft;
+    const shaftEnd = h - headLength;
+    return `<polygon points="${bodyLeft},0 ${bodyRight},0 ${bodyRight},${shaftEnd} ${w},${shaftEnd} ${w / 2},${h} 0,${shaftEnd} ${bodyLeft},${shaftEnd}"/>`;
+  },
+  line: () => "",
+  cloud: (w, h) => `<rect width="${w}" height="${h}" rx="${Math.min(w, h) * 0.15}"/>`,
+  heart: (w, h) => {
+    const cx = w / 2;
+    return `<path d="M ${cx} ${h * 0.35} C ${cx} ${h * 0.1}, 0 0, 0 ${h * 0.35} C 0 ${h * 0.65}, ${cx} ${h * 0.85}, ${cx} ${h} C ${cx} ${h * 0.85}, ${w} ${h * 0.65}, ${w} ${h * 0.35} C ${w} 0, ${cx} ${h * 0.1}, ${cx} ${h * 0.35} Z"/>`;
+  },
+  // =====================
+  // Additional polygons
+  // =====================
+  heptagon: (w, h) => regularPolygon(w, h, 7),
+  octagon: (w, h) => regularPolygon(w, h, 8),
+  decagon: (w, h) => regularPolygon(w, h, 10),
+  dodecagon: (w, h) => regularPolygon(w, h, 12),
+  // =====================
+  // Stars
+  // =====================
+  star6: (w, h) => starPolygon(w, h, 6, 0.5),
+  star8: (w, h) => starPolygon(w, h, 8, 0.38),
+  star10: (w, h) => starPolygon(w, h, 10, 0.38),
+  star12: (w, h) => starPolygon(w, h, 12, 0.38),
+  star16: (w, h) => starPolygon(w, h, 16, 0.38),
+  star24: (w, h) => starPolygon(w, h, 24, 0.38),
+  star32: (w, h) => starPolygon(w, h, 32, 0.38),
+  irregularSeal1: (w, h) => `<polygon points="${w * 0.15},${h * 0.35} ${w * 0.27},${h * 0.03} ${w * 0.38},${h * 0.28} ${w * 0.5},0 ${w * 0.6},${h * 0.23} ${w * 0.73},${h * 0.08} ${w * 0.72},${h * 0.35} ${w},${h * 0.35} ${w * 0.78},${h * 0.5} ${w * 0.95},${h * 0.7} ${w * 0.73},${h * 0.65} ${w * 0.65},${h} ${w * 0.5},${h * 0.72} ${w * 0.35},${h * 0.95} ${w * 0.32},${h * 0.65} ${w * 0.05},${h * 0.7} ${w * 0.18},${h * 0.5} 0,${h * 0.35}"/>`,
+  irregularSeal2: (w, h) => `<polygon points="${w * 0.1},${h * 0.4} ${w * 0.18},${h * 0.08} ${w * 0.32},${h * 0.3} ${w * 0.45},0 ${w * 0.55},${h * 0.18} ${w * 0.72},${h * 0.05} ${w * 0.68},${h * 0.32} ${w},${h * 0.3} ${w * 0.82},${h * 0.5} ${w * 0.98},${h * 0.68} ${w * 0.75},${h * 0.65} ${w * 0.8},${h * 0.92} ${w * 0.55},${h * 0.75} ${w * 0.42},${h} ${w * 0.38},${h * 0.72} ${w * 0.12},${h * 0.88} ${w * 0.22},${h * 0.6} 0,${h * 0.55}"/>`,
+  // =====================
+  // Additional arrows
+  // =====================
+  leftRightArrow: (w, h, adj) => {
+    const headW = (adj["adj1"] ?? 5e4) / 1e5 * h;
+    const headL = (adj["adj2"] ?? 5e4) / 1e5 * w;
+    const bodyTop = (h - headW) / 2;
+    const bodyBot = h - bodyTop;
+    return `<polygon points="${headL},${bodyTop} ${headL},0 0,${h / 2} ${headL},${h} ${headL},${bodyBot} ${w - headL},${bodyBot} ${w - headL},${h} ${w},${h / 2} ${w - headL},0 ${w - headL},${bodyTop}"/>`;
+  },
+  upDownArrow: (w, h, adj) => {
+    const headW = (adj["adj1"] ?? 5e4) / 1e5 * w;
+    const headL = (adj["adj2"] ?? 5e4) / 1e5 * h;
+    const bodyL = (w - headW) / 2;
+    const bodyR = w - bodyL;
+    return `<polygon points="${bodyL},${headL} 0,${headL} ${w / 2},0 ${w},${headL} ${bodyR},${headL} ${bodyR},${h - headL} ${w},${h - headL} ${w / 2},${h} 0,${h - headL} ${bodyL},${h - headL}"/>`;
+  },
+  notchedRightArrow: (w, h, adj) => {
+    const headWidth = (adj["adj1"] ?? 5e4) / 1e5 * h;
+    const headLength = (adj["adj2"] ?? 5e4) / 1e5 * w;
+    const bodyTop = (h - headWidth) / 2;
+    const bodyBottom = h - bodyTop;
+    const shaftEnd = w - headLength;
+    const notch = headLength * 0.5;
+    return `<polygon points="0,${bodyTop} ${shaftEnd},${bodyTop} ${shaftEnd},0 ${w},${h / 2} ${shaftEnd},${h} ${shaftEnd},${bodyBottom} 0,${bodyBottom} ${notch},${h / 2}"/>`;
+  },
+  stripedRightArrow: (w, h, adj) => {
+    const headWidth = (adj["adj1"] ?? 5e4) / 1e5 * h;
+    const headLength = (adj["adj2"] ?? 5e4) / 1e5 * w;
+    const bodyTop = (h - headWidth) / 2;
+    const bodyBottom = h - bodyTop;
+    const shaftEnd = w - headLength;
+    const sw = w * 0.05;
+    return `<path d="M 0 ${bodyTop} L ${sw} ${bodyTop} L ${sw} ${bodyBottom} L 0 ${bodyBottom} Z M ${sw * 1.5} ${bodyTop} L ${sw * 2.5} ${bodyTop} L ${sw * 2.5} ${bodyBottom} L ${sw * 1.5} ${bodyBottom} Z M ${sw * 3} ${bodyTop} L ${shaftEnd} ${bodyTop} L ${shaftEnd} 0 L ${w} ${h / 2} L ${shaftEnd} ${h} L ${shaftEnd} ${bodyBottom} L ${sw * 3} ${bodyBottom} Z"/>`;
+  },
+  chevron: (w, h, adj) => {
+    const offset = (adj["adj"] ?? 5e4) / 1e5 * w;
+    return `<polygon points="0,0 ${w - offset},0 ${w},${h / 2} ${w - offset},${h} 0,${h} ${offset},${h / 2}"/>`;
+  },
+  homePlate: (w, h, adj) => {
+    const offset = (adj["adj"] ?? 5e4) / 1e5 * w;
+    return `<polygon points="0,0 ${w - offset},0 ${w},${h / 2} ${w - offset},${h} 0,${h}"/>`;
+  },
+  leftRightUpArrow: (w, h, adj) => {
+    const headW = (adj["adj1"] ?? 25e3) / 1e5 * Math.min(w, h);
+    const headL = (adj["adj2"] ?? 25e3) / 1e5 * Math.min(w, h);
+    const bodyW = (adj["adj3"] ?? 25e3) / 1e5 * Math.min(w, h);
+    const cx = w / 2;
+    const bodyHalf = bodyW / 2;
+    const bodyMid = h - headL - bodyW;
+    return `<path d="M ${cx} 0 L ${cx + headW / 2} ${headL} L ${cx + bodyHalf} ${headL} L ${cx + bodyHalf} ${bodyMid} L ${w - headL} ${bodyMid} L ${w - headL} ${h / 2 + bodyMid / 2 - headW / 2} L ${w} ${h / 2 + bodyMid / 2} L ${w - headL} ${h / 2 + bodyMid / 2 + headW / 2} L ${w - headL} ${bodyMid + bodyW} L ${cx + bodyHalf} ${bodyMid + bodyW} L ${cx + bodyHalf} ${bodyMid + bodyW} L ${cx - bodyHalf} ${bodyMid + bodyW} L ${cx - bodyHalf} ${bodyMid + bodyW} L ${headL} ${bodyMid + bodyW} L ${headL} ${h / 2 + bodyMid / 2 + headW / 2} L 0 ${h / 2 + bodyMid / 2} L ${headL} ${h / 2 + bodyMid / 2 - headW / 2} L ${headL} ${bodyMid} L ${cx - bodyHalf} ${bodyMid} L ${cx - bodyHalf} ${headL} L ${cx - headW / 2} ${headL} Z"/>`;
+  },
+  quadArrow: (w, h, adj) => {
+    const headW = (adj["adj1"] ?? 22500) / 1e5 * Math.min(w, h);
+    const headL = (adj["adj2"] ?? 22500) / 1e5 * Math.min(w, h);
+    const bodyW = (adj["adj3"] ?? 11250) / 1e5 * Math.min(w, h);
+    const cx = w / 2;
+    const cy = h / 2;
+    const bh = bodyW / 2;
+    return `<path d="M ${cx} 0 L ${cx + headW / 2} ${headL} L ${cx + bh} ${headL} L ${cx + bh} ${cy - bh} L ${w - headL} ${cy - bh} L ${w - headL} ${cy - headW / 2} L ${w} ${cy} L ${w - headL} ${cy + headW / 2} L ${w - headL} ${cy + bh} L ${cx + bh} ${cy + bh} L ${cx + bh} ${h - headL} L ${cx + headW / 2} ${h - headL} L ${cx} ${h} L ${cx - headW / 2} ${h - headL} L ${cx - bh} ${h - headL} L ${cx - bh} ${cy + bh} L ${headL} ${cy + bh} L ${headL} ${cy + headW / 2} L 0 ${cy} L ${headL} ${cy - headW / 2} L ${headL} ${cy - bh} L ${cx - bh} ${cy - bh} L ${cx - bh} ${headL} L ${cx - headW / 2} ${headL} Z"/>`;
+  },
+  bentArrow: (w, h, adj) => {
+    const headW = (adj["adj1"] ?? 25e3) / 1e5 * h;
+    const headL = (adj["adj2"] ?? 25e3) / 1e5 * w;
+    const bodyW = (adj["adj3"] ?? 25e3) / 1e5 * h;
+    const shaftEnd = w - headL;
+    const arrowTop = 0;
+    const bodyTop = headW / 2 - bodyW / 2;
+    const bodyBot = headW / 2 + bodyW / 2;
+    return `<polygon points="${shaftEnd},${bodyTop} ${shaftEnd},${arrowTop} ${w},${headW / 2} ${shaftEnd},${headW} ${shaftEnd},${bodyBot} ${bodyW},${bodyBot} ${bodyW},${h} 0,${h} 0,${h - bodyW} ${0},${h - bodyW}"/>`;
+  },
+  bendUpArrow: (w, h, adj) => {
+    const headW = (adj["adj1"] ?? 25e3) / 1e5 * w;
+    const headL = (adj["adj2"] ?? 25e3) / 1e5 * h;
+    const bodyW = (adj["adj3"] ?? 25e3) / 1e5 * w;
+    const cx = w - headW / 2;
+    const bodyLeft = cx - bodyW / 2;
+    const bodyRight = cx + bodyW / 2;
+    return `<polygon points="${cx - headW / 2},${headL} ${cx},0 ${cx + headW / 2},${headL} ${bodyRight},${headL} ${bodyRight},${h - bodyW} ${bodyW},${h - bodyW} ${bodyW},${h} 0,${h} 0,${h - bodyW} ${bodyLeft},${h - bodyW} ${bodyLeft},${headL}"/>`;
+  },
+  leftUpArrow: (w, h, adj) => {
+    const headW = (adj["adj1"] ?? 25e3) / 1e5 * Math.min(w, h);
+    const headL = (adj["adj2"] ?? 25e3) / 1e5 * Math.min(w, h);
+    const bodyW = (adj["adj3"] ?? 25e3) / 1e5 * Math.min(w, h);
+    const bh = bodyW / 2;
+    const topCx = w - headW / 2;
+    const leftCy = h - headW / 2;
+    return `<path d="M ${topCx} 0 L ${topCx + headW / 2} ${headL} L ${topCx + bh} ${headL} L ${topCx + bh} ${leftCy - bh} L ${headL} ${leftCy - bh} L ${headL} ${leftCy - headW / 2} L 0 ${leftCy} L ${headL} ${leftCy + headW / 2} L ${headL} ${leftCy + bh} L ${topCx - bh} ${leftCy + bh} L ${topCx - bh} ${headL} L ${topCx - headW / 2} ${headL} Z"/>`;
+  },
+  uturnArrow: (w, h, adj) => {
+    const headW = (adj["adj1"] ?? 25e3) / 1e5 * w;
+    const headL = (adj["adj2"] ?? 25e3) / 1e5 * h;
+    const bodyW = (adj["adj3"] ?? 25e3) / 1e5 * w;
+    const arcR = w * 0.35;
+    const cx = w / 2;
+    const arrowBot = h;
+    const arrowStart = h - headL;
+    const bodyRight = w - (headW / 2 - bodyW / 2);
+    const bodyLeft = w - (headW / 2 + bodyW / 2);
+    return `<path d="M ${w - headW / 2 - headW / 2} ${arrowStart} L ${w - headW / 2} ${arrowBot} L ${w} ${arrowStart} L ${bodyRight} ${arrowStart} L ${bodyRight} ${arcR} A ${arcR} ${arcR} 0 0 0 ${bodyW} ${arcR} L ${bodyW} ${arrowStart} L 0 ${arrowStart} L 0 ${arcR} A ${cx} ${cx} 0 0 1 ${bodyLeft} ${arcR} L ${bodyLeft} ${arrowStart} Z"/>`;
+  },
+  // =====================
+  // Flowchart shapes
+  // =====================
+  flowChartProcess: (w, h) => `<rect width="${w}" height="${h}"/>`,
+  flowChartAlternateProcess: (w, h) => {
+    const r = Math.min(w, h) / 6;
+    return `<rect width="${w}" height="${h}" rx="${r}" ry="${r}"/>`;
+  },
+  flowChartDecision: (w, h) => `<polygon points="${w / 2},0 ${w},${h / 2} ${w / 2},${h} 0,${h / 2}"/>`,
+  flowChartInputOutput: (w, h) => {
+    const offset = w / 5;
+    return `<polygon points="${offset},0 ${w},0 ${w - offset},${h} 0,${h}"/>`;
+  },
+  flowChartPredefinedProcess: (w, h) => {
+    const d = w / 8;
+    return `<path d="M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z M ${d} 0 L ${d} ${h} M ${w - d} 0 L ${w - d} ${h}"/>`;
+  },
+  flowChartInternalStorage: (w, h) => {
+    const dx = w / 8;
+    const dy = h / 8;
+    return `<path d="M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z M ${dx} 0 L ${dx} ${h} M 0 ${dy} L ${w} ${dy}"/>`;
+  },
+  flowChartDocument: (w, h) => {
+    const bh = h * 0.83;
+    return `<path d="M 0 0 L ${w} 0 L ${w} ${bh} C ${w * 0.75} ${h}, ${w * 0.25} ${h * 0.66}, 0 ${bh} Z"/>`;
+  },
+  flowChartMultidocument: (w, h) => {
+    const dx = w * 0.1;
+    const dy = h * 0.1;
+    const bw = w - dx;
+    const bh = (h - dy) * 0.83;
+    return `<path d="M ${dx} ${dy} L ${w} ${dy} L ${w} ${dy + bh} C ${w - bw * 0.25} ${dy + (h - dy)}, ${dx + bw * 0.25} ${dy + (h - dy) * 0.66}, ${dx} ${dy + bh} Z M ${dx / 2} ${dy / 2} L ${dx} ${dy / 2} L ${dx} ${dy} M 0 0 L ${dx / 2} 0 L ${dx / 2} ${dy / 2}"/>`;
+  },
+  flowChartTerminator: (w, h) => {
+    const r = h / 2;
+    return `<rect width="${w}" height="${h}" rx="${r}" ry="${r}"/>`;
+  },
+  flowChartPreparation: (w, h) => {
+    const offset = w / 5;
+    return `<polygon points="${offset},0 ${w - offset},0 ${w},${h / 2} ${w - offset},${h} ${offset},${h} 0,${h / 2}"/>`;
+  },
+  flowChartManualInput: (w, h) => {
+    const topY = h / 5;
+    return `<polygon points="0,${topY} ${w},0 ${w},${h} 0,${h}"/>`;
+  },
+  flowChartManualOperation: (w, h) => {
+    const offset = w / 5;
+    return `<polygon points="0,0 ${w},0 ${w - offset},${h} ${offset},${h}"/>`;
+  },
+  flowChartConnector: (w, h) => `<ellipse cx="${w / 2}" cy="${h / 2}" rx="${w / 2}" ry="${h / 2}"/>`,
+  flowChartOffpageConnector: (w, h) => {
+    const arrowH = h * 0.2;
+    return `<polygon points="0,0 ${w},0 ${w},${h - arrowH} ${w / 2},${h} 0,${h - arrowH}"/>`;
+  },
+  flowChartPunchedCard: (w, h) => {
+    const cut = Math.min(w, h) * 0.2;
+    return `<polygon points="${cut},0 ${w},0 ${w},${h} 0,${h} 0,${cut}"/>`;
+  },
+  flowChartPunchedTape: (w, h) => {
+    const wave = h * 0.1;
+    return `<path d="M 0 ${wave} C ${w * 0.25} ${-wave}, ${w * 0.75} ${wave * 3}, ${w} ${wave} L ${w} ${h - wave} C ${w * 0.75} ${h + wave}, ${w * 0.25} ${h - wave * 3}, 0 ${h - wave} Z"/>`;
+  },
+  flowChartCollate: (w, h) => `<polygon points="0,0 ${w},0 ${w / 2},${h / 2} ${w},${h} 0,${h} ${w / 2},${h / 2}"/>`,
+  flowChartSort: (w, h) => `<path d="M ${w / 2} 0 L ${w} ${h / 2} L 0 ${h / 2} Z M 0 ${h / 2} L ${w} ${h / 2} M ${w / 2} ${h} L ${w} ${h / 2} L 0 ${h / 2} Z"/>`,
+  flowChartExtract: (w, h) => `<polygon points="${w / 2},0 ${w},${h} 0,${h}"/>`,
+  flowChartMerge: (w, h) => `<polygon points="0,0 ${w},0 ${w / 2},${h}"/>`,
+  flowChartOnlineStorage: (w, h) => {
+    const arcW = w * 0.15;
+    return `<path d="M ${arcW} 0 L ${w} 0 L ${w} ${h} L ${arcW} ${h} A ${arcW} ${h / 2} 0 0 1 ${arcW} 0 Z"/>`;
+  },
+  flowChartDelay: (w, h) => {
+    const arcW = w * 0.35;
+    return `<path d="M 0 0 L ${w - arcW} 0 A ${arcW} ${h / 2} 0 0 1 ${w - arcW} ${h} L 0 ${h} Z"/>`;
+  },
+  flowChartDisplay: (w, h) => {
+    const leftW = w * 0.15;
+    const arcW = w * 0.35;
+    return `<path d="M ${leftW} 0 L ${w - arcW} 0 A ${arcW} ${h / 2} 0 0 1 ${w - arcW} ${h} L ${leftW} ${h} L 0 ${h / 2} Z"/>`;
+  },
+  flowChartMagneticTape: (w, h) => {
+    const r = Math.min(w, h) / 2;
+    const cx = w / 2;
+    const cy = h / 2;
+    return `<path d="M ${cx + r} ${cy} A ${r} ${r} 0 1 1 ${cx + r - 0.01} ${cy + 0.01} L ${w} ${cy} L ${w} ${h} L ${w - r * 0.3} ${h} L ${cx + r * Math.cos(Math.PI / 6)} ${cy + r * Math.sin(Math.PI / 6)}"/>`;
+  },
+  flowChartMagneticDisk: (w, h) => {
+    const ry = h * 0.15;
+    return `<path d="M 0 ${ry} A ${w / 2} ${ry} 0 0 1 ${w} ${ry} L ${w} ${h - ry} A ${w / 2} ${ry} 0 0 1 0 ${h - ry} Z M 0 ${ry} A ${w / 2} ${ry} 0 0 0 ${w} ${ry}"/>`;
+  },
+  flowChartMagneticDrum: (w, h) => {
+    const rx = w * 0.15;
+    return `<path d="M ${rx} 0 A ${rx} ${h / 2} 0 0 0 ${rx} ${h} L ${w - rx} ${h} A ${rx} ${h / 2} 0 0 0 ${w - rx} 0 Z M ${w - rx} 0 A ${rx} ${h / 2} 0 0 1 ${w - rx} ${h}"/>`;
+  },
+  flowChartSummingJunction: (w, h) => {
+    const cx = w / 2;
+    const cy = h / 2;
+    const rx = w / 2;
+    const ry = h / 2;
+    const d = 0.707;
+    return `<path d="M ${cx + rx} ${cy} A ${rx} ${ry} 0 1 1 ${cx + rx - 0.01} ${cy - 0.01} Z M ${cx - rx * d} ${cy - ry * d} L ${cx + rx * d} ${cy + ry * d} M ${cx + rx * d} ${cy - ry * d} L ${cx - rx * d} ${cy + ry * d}"/>`;
+  },
+  flowChartOr: (w, h) => {
+    const cx = w / 2;
+    const cy = h / 2;
+    const rx = w / 2;
+    const ry = h / 2;
+    return `<path d="M ${cx + rx} ${cy} A ${rx} ${ry} 0 1 1 ${cx + rx - 0.01} ${cy - 0.01} Z M ${cx} 0 L ${cx} ${h} M 0 ${cy} L ${w} ${cy}"/>`;
+  },
+  // =====================
+  // Callout shapes
+  // =====================
+  wedgeRectCallout: (w, h, adj) => {
+    const tipX = w / 2 + (adj["adj1"] ?? -20833) / 1e5 * w;
+    const tipY = h / 2 + (adj["adj2"] ?? 62500) / 1e5 * h;
+    const bx = w / 2;
+    const wedgeW = w * 0.06;
+    return `<path d="M 0 0 L ${w} 0 L ${w} ${h} L ${bx + wedgeW} ${h} L ${tipX} ${tipY} L ${bx - wedgeW} ${h} L 0 ${h} Z"/>`;
+  },
+  wedgeRoundRectCallout: (w, h, adj) => {
+    const tipX = w / 2 + (adj["adj1"] ?? -20833) / 1e5 * w;
+    const tipY = h / 2 + (adj["adj2"] ?? 62500) / 1e5 * h;
+    const r = (adj["adj3"] ?? 16667) / 1e5 * Math.min(w, h);
+    const bx = w / 2;
+    const wedgeW = w * 0.06;
+    return `<path d="M ${r} 0 L ${w - r} 0 A ${r} ${r} 0 0 1 ${w} ${r} L ${w} ${h - r} A ${r} ${r} 0 0 1 ${w - r} ${h} L ${bx + wedgeW} ${h} L ${tipX} ${tipY} L ${bx - wedgeW} ${h} L ${r} ${h} A ${r} ${r} 0 0 1 0 ${h - r} L 0 ${r} A ${r} ${r} 0 0 1 ${r} 0 Z"/>`;
+  },
+  wedgeEllipseCallout: (w, h, adj) => {
+    const tipX = w / 2 + (adj["adj1"] ?? -20833) / 1e5 * w;
+    const tipY = h / 2 + (adj["adj2"] ?? 62500) / 1e5 * h;
+    const cx = w / 2;
+    const cy = h / 2;
+    const rx = w / 2;
+    const ry = h / 2;
+    const angle = Math.atan2(tipY - cy, tipX - cx);
+    const wedgeAngle = 0.15;
+    const x1 = cx + rx * Math.cos(angle - wedgeAngle);
+    const y1 = cy + ry * Math.sin(angle - wedgeAngle);
+    const x2 = cx + rx * Math.cos(angle + wedgeAngle);
+    const y2 = cy + ry * Math.sin(angle + wedgeAngle);
+    return `<path d="M ${x1} ${y1} L ${tipX} ${tipY} L ${x2} ${y2} A ${rx} ${ry} 0 1 1 ${x1} ${y1} Z"/>`;
+  },
+  cloudCallout: (w, h, adj) => {
+    const tipX = w / 2 + (adj["adj1"] ?? -20833) / 1e5 * w;
+    const tipY = h / 2 + (adj["adj2"] ?? 62500) / 1e5 * h;
+    const r = Math.min(w, h) * 0.15;
+    const bx = w / 2;
+    const by = h / 2;
+    const dx = tipX - bx;
+    const dy = tipY - by;
+    const d1x = bx + dx * 0.33;
+    const d1y = by + dy * 0.33;
+    const d2x = bx + dx * 0.66;
+    const d2y = by + dy * 0.66;
+    return `<path d="M ${r} ${h} A ${r} ${r} 0 0 1 0 ${h - r} A ${r} ${r} 0 0 1 ${r} ${h - 2 * r} L ${r} ${r} A ${r} ${r} 0 0 1 ${2 * r} 0 L ${w - 2 * r} 0 A ${r} ${r} 0 0 1 ${w - r} ${r} L ${w - r} ${h - 2 * r} A ${r} ${r} 0 0 1 ${w - 2 * r} ${h - r} A ${r} ${r} 0 0 1 ${w - 2 * r} ${h} Z M ${d1x} ${d1y} m ${r * 0.25} 0 a ${r * 0.25} ${r * 0.25} 0 1 1 -${r * 0.5} 0 a ${r * 0.25} ${r * 0.25} 0 1 1 ${r * 0.5} 0 Z M ${d2x} ${d2y} m ${r * 0.15} 0 a ${r * 0.15} ${r * 0.15} 0 1 1 -${r * 0.3} 0 a ${r * 0.15} ${r * 0.15} 0 1 1 ${r * 0.3} 0 Z"/>`;
+  },
+  borderCallout1: (w, h, adj) => {
+    const y1 = (adj["adj1"] ?? 18750) / 1e5 * h;
+    const x1 = (adj["adj2"] ?? -8333) / 1e5 * w;
+    const y2 = (adj["adj3"] ?? 112500) / 1e5 * h;
+    const x2 = (adj["adj4"] ?? -38333) / 1e5 * w;
+    return `<path d="M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z M ${x1} ${y1} L ${x2} ${y2}"/>`;
+  },
+  borderCallout2: (w, h, adj) => {
+    const y1 = (adj["adj1"] ?? 18750) / 1e5 * h;
+    const x1 = (adj["adj2"] ?? -8333) / 1e5 * w;
+    const y2 = (adj["adj3"] ?? 18750) / 1e5 * h;
+    const x2 = (adj["adj4"] ?? -16667) / 1e5 * w;
+    const y3 = (adj["adj5"] ?? 112500) / 1e5 * h;
+    const x3 = (adj["adj6"] ?? -46667) / 1e5 * w;
+    return `<path d="M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z M ${x1} ${y1} L ${x2} ${y2} L ${x3} ${y3}"/>`;
+  },
+  borderCallout3: (w, h, adj) => {
+    const y1 = (adj["adj1"] ?? 18750) / 1e5 * h;
+    const x1 = (adj["adj2"] ?? -8333) / 1e5 * w;
+    const y2 = (adj["adj3"] ?? 18750) / 1e5 * h;
+    const x2 = (adj["adj4"] ?? -16667) / 1e5 * w;
+    const y3 = (adj["adj5"] ?? 1e5) / 1e5 * h;
+    const x3 = (adj["adj6"] ?? -16667) / 1e5 * w;
+    const y4 = (adj["adj7"] ?? 112963) / 1e5 * h;
+    const x4 = (adj["adj8"] ?? -46667) / 1e5 * w;
+    return `<path d="M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z M ${x1} ${y1} L ${x2} ${y2} L ${x3} ${y3} L ${x4} ${y4}"/>`;
+  },
+  // =====================
+  // Arc shapes
+  // =====================
+  arc: (w, h, adj) => {
+    const stAng = ooxmlAngleToRadians(adj["adj1"] ?? 162e5);
+    const endAng = ooxmlAngleToRadians(adj["adj2"] ?? 0);
+    const rx = w / 2;
+    const ry = h / 2;
+    const cx = rx;
+    const cy = ry;
+    const x1 = cx + rx * Math.cos(stAng);
+    const y1 = cy - ry * Math.sin(stAng);
+    const x2 = cx + rx * Math.cos(endAng);
+    const y2 = cy - ry * Math.sin(endAng);
+    let sweep = stAng - endAng;
+    if (sweep < 0) sweep += 2 * Math.PI;
+    const largeArc = sweep > Math.PI ? 1 : 0;
+    return `<path d="M ${x1} ${y1} A ${rx} ${ry} 0 ${largeArc} 0 ${x2} ${y2}"/>`;
+  },
+  chord: (w, h, adj) => {
+    const stAng = ooxmlAngleToRadians(adj["adj1"] ?? 27e5);
+    const endAng = ooxmlAngleToRadians(adj["adj2"] ?? 162e5);
+    const rx = w / 2;
+    const ry = h / 2;
+    const cx = rx;
+    const cy = ry;
+    const x1 = cx + rx * Math.cos(stAng);
+    const y1 = cy - ry * Math.sin(stAng);
+    const x2 = cx + rx * Math.cos(endAng);
+    const y2 = cy - ry * Math.sin(endAng);
+    let sweep = stAng - endAng;
+    if (sweep < 0) sweep += 2 * Math.PI;
+    const largeArc = sweep > Math.PI ? 1 : 0;
+    return `<path d="M ${x1} ${y1} A ${rx} ${ry} 0 ${largeArc} 0 ${x2} ${y2} Z"/>`;
+  },
+  pie: (w, h, adj) => {
+    const stAng = ooxmlAngleToRadians(adj["adj1"] ?? 0);
+    const endAng = ooxmlAngleToRadians(adj["adj2"] ?? 162e5);
+    const rx = w / 2;
+    const ry = h / 2;
+    const cx = rx;
+    const cy = ry;
+    const x1 = cx + rx * Math.cos(stAng);
+    const y1 = cy - ry * Math.sin(stAng);
+    const x2 = cx + rx * Math.cos(endAng);
+    const y2 = cy - ry * Math.sin(endAng);
+    let sweep = stAng - endAng;
+    if (sweep < 0) sweep += 2 * Math.PI;
+    const largeArc = sweep > Math.PI ? 1 : 0;
+    return `<path d="M ${cx} ${cy} L ${x1} ${y1} A ${rx} ${ry} 0 ${largeArc} 0 ${x2} ${y2} Z"/>`;
+  },
+  blockArc: (w, h, adj) => {
+    const stAng = ooxmlAngleToRadians(adj["adj1"] ?? 108e5);
+    const endAng = ooxmlAngleToRadians(adj["adj2"] ?? 0);
+    const thickness = (adj["adj3"] ?? 25e3) / 1e5;
+    const rx = w / 2;
+    const ry = h / 2;
+    const cx = rx;
+    const cy = ry;
+    const irx = rx * (1 - thickness);
+    const iry = ry * (1 - thickness);
+    const ox1 = cx + rx * Math.cos(stAng);
+    const oy1 = cy - ry * Math.sin(stAng);
+    const ox2 = cx + rx * Math.cos(endAng);
+    const oy2 = cy - ry * Math.sin(endAng);
+    const ix1 = cx + irx * Math.cos(stAng);
+    const iy1 = cy - iry * Math.sin(stAng);
+    const ix2 = cx + irx * Math.cos(endAng);
+    const iy2 = cy - iry * Math.sin(endAng);
+    let sweep = stAng - endAng;
+    if (sweep < 0) sweep += 2 * Math.PI;
+    const largeArc = sweep > Math.PI ? 1 : 0;
+    return `<path d="M ${ox1} ${oy1} A ${rx} ${ry} 0 ${largeArc} 0 ${ox2} ${oy2} L ${ix2} ${iy2} A ${irx} ${iry} 0 ${largeArc} 1 ${ix1} ${iy1} Z"/>`;
+  },
+  // =====================
+  // Math shapes
+  // =====================
+  mathPlus: (w, h, adj) => {
+    const t = (adj["adj1"] ?? 23520) / 1e5;
+    const tw = t * w;
+    const th = t * h;
+    const lx = (w - tw) / 2;
+    const rx = lx + tw;
+    const ty = (h - th) / 2;
+    const by = ty + th;
+    return `<polygon points="${lx},0 ${rx},0 ${rx},${ty} ${w},${ty} ${w},${by} ${rx},${by} ${rx},${h} ${lx},${h} ${lx},${by} 0,${by} 0,${ty} ${lx},${ty}"/>`;
+  },
+  mathMinus: (w, h, adj) => {
+    const t = (adj["adj1"] ?? 23520) / 1e5;
+    const th = t * h;
+    const ty = (h - th) / 2;
+    const by = ty + th;
+    return `<rect x="0" y="${ty}" width="${w}" height="${by - ty}"/>`;
+  },
+  mathMultiply: (w, h, adj) => {
+    const t = (adj["adj1"] ?? 23520) / 1e5;
+    const d = t * Math.min(w, h) * 0.5;
+    const cx = w / 2;
+    const cy = h / 2;
+    return `<path d="M ${cx} ${cy - d} L ${w - d} 0 L ${w} ${d} L ${cx + d} ${cy} L ${w} ${h - d} L ${w - d} ${h} L ${cx} ${cy + d} L ${d} ${h} L 0 ${h - d} L ${cx - d} ${cy} L 0 ${d} L ${d} 0 Z"/>`;
+  },
+  mathDivide: (w, h, adj) => {
+    const t = (adj["adj1"] ?? 23520) / 1e5;
+    const th = t * h;
+    const ty = (h - th) / 2;
+    const by = ty + th;
+    const dotR = Math.min(w, h) * t * 0.5;
+    const cx = w / 2;
+    const topDotY = ty / 2;
+    const botDotY = h - ty / 2;
+    return `<path d="M 0 ${ty} L ${w} ${ty} L ${w} ${by} L 0 ${by} Z M ${cx + dotR} ${topDotY} A ${dotR} ${dotR} 0 1 1 ${cx + dotR - 0.01} ${topDotY - 0.01} Z M ${cx + dotR} ${botDotY} A ${dotR} ${dotR} 0 1 1 ${cx + dotR - 0.01} ${botDotY - 0.01} Z"/>`;
+  },
+  mathEqual: (w, h, adj) => {
+    const t = (adj["adj1"] ?? 23520) / 1e5;
+    const gap = t * h;
+    const barH = t * h;
+    const y1 = (h - gap) / 2 - barH;
+    const y2 = (h + gap) / 2;
+    return `<path d="M 0 ${y1} L ${w} ${y1} L ${w} ${y1 + barH} L 0 ${y1 + barH} Z M 0 ${y2} L ${w} ${y2} L ${w} ${y2 + barH} L 0 ${y2 + barH} Z"/>`;
+  },
+  mathNotEqual: (w, h, adj) => {
+    const t = (adj["adj1"] ?? 23520) / 1e5;
+    const gap = t * h;
+    const barH = t * h;
+    const y1 = (h - gap) / 2 - barH;
+    const y2 = (h + gap) / 2;
+    const slashW = w * 0.15;
+    const sx = w / 2 - slashW / 2;
+    return `<path d="M 0 ${y1} L ${w} ${y1} L ${w} ${y1 + barH} L 0 ${y1 + barH} Z M 0 ${y2} L ${w} ${y2} L ${w} ${y2 + barH} L 0 ${y2 + barH} Z M ${sx + slashW} ${y1 - barH} L ${sx + slashW + slashW} ${y1 - barH} L ${sx} ${y2 + barH + barH} L ${sx - slashW} ${y2 + barH + barH} Z"/>`;
+  },
+  // =====================
+  // Other shapes
+  // =====================
+  plus: (w, h, adj) => {
+    const t = (adj["adj"] ?? 25e3) / 1e5;
+    const lx = t * w;
+    const rx = w - lx;
+    const ty = t * h;
+    const by = h - ty;
+    return `<polygon points="${lx},0 ${rx},0 ${rx},${ty} ${w},${ty} ${w},${by} ${rx},${by} ${rx},${h} ${lx},${h} ${lx},${by} 0,${by} 0,${ty} ${lx},${ty}"/>`;
+  },
+  corner: (w, h, adj) => {
+    const adjX = (adj["adj1"] ?? 5e4) / 1e5;
+    const adjY = (adj["adj2"] ?? 5e4) / 1e5;
+    const cx = adjX * w;
+    const cy = adjY * h;
+    return `<polygon points="0,0 ${cx},0 ${cx},${cy} ${w},${cy} ${w},${h} 0,${h}"/>`;
+  },
+  diagStripe: (w, h, adj) => {
+    const d = (adj["adj"] ?? 5e4) / 1e5 * Math.min(w, h);
+    return `<polygon points="0,${d} ${d},0 ${w},0 0,${h}"/>`;
+  },
+  foldedCorner: (w, h, adj) => {
+    const fold = (adj["adj"] ?? 16667) / 1e5 * Math.min(w, h);
+    return `<path d="M 0 0 L ${w} 0 L ${w} ${h - fold} L ${w - fold} ${h} L 0 ${h} Z M ${w - fold} ${h} L ${w - fold} ${h - fold} L ${w} ${h - fold}"/>`;
+  },
+  plaque: (w, h, adj) => {
+    const r = (adj["adj"] ?? 16667) / 1e5 * Math.min(w, h);
+    return `<path d="M 0 ${r} A ${r} ${r} 0 0 1 ${r} 0 L ${w - r} 0 A ${r} ${r} 0 0 1 ${w} ${r} L ${w} ${h - r} A ${r} ${r} 0 0 1 ${w - r} ${h} L ${r} ${h} A ${r} ${r} 0 0 1 0 ${h - r} Z"/>`;
+  },
+  can: (w, h, adj) => {
+    const ry = (adj["adj"] ?? 25e3) / 1e5 * h * 0.5;
+    return `<path d="M 0 ${ry} A ${w / 2} ${ry} 0 0 1 ${w} ${ry} L ${w} ${h - ry} A ${w / 2} ${ry} 0 0 1 0 ${h - ry} Z M 0 ${ry} A ${w / 2} ${ry} 0 0 0 ${w} ${ry}"/>`;
+  },
+  cube: (w, h, adj) => {
+    const d = (adj["adj"] ?? 25e3) / 1e5 * Math.min(w, h);
+    return `<path d="M 0 ${d} L ${d} 0 L ${w} 0 L ${w} ${h - d} L ${w - d} ${h} L 0 ${h} Z M 0 ${d} L ${w - d} ${d} L ${w} 0 M ${w - d} ${d} L ${w - d} ${h}"/>`;
+  },
+  donut: (w, h, adj) => {
+    const t = (adj["adj"] ?? 25e3) / 1e5;
+    const rx = w / 2;
+    const ry = h / 2;
+    const irx = rx * (1 - t);
+    const iry = ry * (1 - t);
+    const cx = rx;
+    const cy = ry;
+    return `<path fill-rule="evenodd" d="M ${cx + rx} ${cy} A ${rx} ${ry} 0 1 1 ${cx - rx} ${cy} A ${rx} ${ry} 0 1 1 ${cx + rx} ${cy} Z M ${cx + irx} ${cy} A ${irx} ${iry} 0 1 0 ${cx - irx} ${cy} A ${irx} ${iry} 0 1 0 ${cx + irx} ${cy} Z"/>`;
+  },
+  noSmoking: (w, h, adj) => {
+    const t = (adj["adj"] ?? 18750) / 1e5;
+    const rx = w / 2;
+    const ry = h / 2;
+    const cx = rx;
+    const cy = ry;
+    const irx = rx * (1 - t);
+    const iry = ry * (1 - t);
+    const angle = Math.PI / 4;
+    const lx1 = cx + irx * Math.cos(angle);
+    const ly1 = cy - iry * Math.sin(angle);
+    const lx2 = cx - irx * Math.cos(angle);
+    const ly2 = cy + iry * Math.sin(angle);
+    return `<path fill-rule="evenodd" d="M ${cx + rx} ${cy} A ${rx} ${ry} 0 1 1 ${cx - rx} ${cy} A ${rx} ${ry} 0 1 1 ${cx + rx} ${cy} Z M ${cx + irx} ${cy} A ${irx} ${iry} 0 1 0 ${cx - irx} ${cy} A ${irx} ${iry} 0 1 0 ${cx + irx} ${cy} Z M ${lx1} ${ly1} L ${lx2} ${ly2}"/>`;
+  },
+  smileyFace: (w, h, adj) => {
+    const smile = (adj["adj"] ?? 4653) / 1e5;
+    const rx = w / 2;
+    const ry = h / 2;
+    const cx = rx;
+    const cy = ry;
+    const eyeRx = w * 0.06;
+    const eyeRy = h * 0.06;
+    const eyeY = h * 0.35;
+    const leftEyeX = w * 0.35;
+    const rightEyeX = w * 0.65;
+    const mouthY = h * 0.6;
+    const mouthW = w * 0.3;
+    const mouthCurve = smile * h;
+    return `<path d="M ${cx + rx} ${cy} A ${rx} ${ry} 0 1 1 ${cx - rx} ${cy} A ${rx} ${ry} 0 1 1 ${cx + rx} ${cy} Z M ${leftEyeX + eyeRx} ${eyeY} A ${eyeRx} ${eyeRy} 0 1 1 ${leftEyeX - eyeRx} ${eyeY} A ${eyeRx} ${eyeRy} 0 1 1 ${leftEyeX + eyeRx} ${eyeY} Z M ${rightEyeX + eyeRx} ${eyeY} A ${eyeRx} ${eyeRy} 0 1 1 ${rightEyeX - eyeRx} ${eyeY} A ${eyeRx} ${eyeRy} 0 1 1 ${rightEyeX + eyeRx} ${eyeY} Z M ${cx - mouthW} ${mouthY} C ${cx - mouthW * 0.5} ${mouthY + mouthCurve}, ${cx + mouthW * 0.5} ${mouthY + mouthCurve}, ${cx + mouthW} ${mouthY}"/>`;
+  },
+  frame: (w, h, adj) => {
+    const t = (adj["adj1"] ?? 12500) / 1e5 * Math.min(w, h);
+    return `<path fill-rule="evenodd" d="M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z M ${t} ${t} L ${t} ${h - t} L ${w - t} ${h - t} L ${w - t} ${t} Z"/>`;
+  },
+  bevel: (w, h, adj) => {
+    const t = (adj["adj"] ?? 12500) / 1e5 * Math.min(w, h);
+    return `<path d="M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z M ${t} ${t} L ${w - t} ${t} L ${w - t} ${h - t} L ${t} ${h - t} Z M 0 0 L ${t} ${t} M ${w} 0 L ${w - t} ${t} M ${w} ${h} L ${w - t} ${h - t} M 0 ${h} L ${t} ${h - t}"/>`;
+  },
+  halfFrame: (w, h, adj) => {
+    const adjX = (adj["adj1"] ?? 33333) / 1e5 * w;
+    const adjY = (adj["adj2"] ?? 33333) / 1e5 * h;
+    return `<polygon points="0,0 ${w},0 ${w},${adjY} ${adjX},${adjY} ${adjX},${h} 0,${h}"/>`;
+  },
+  // Snip/Round corner rectangles
+  snip1Rect: (w, h, adj) => {
+    const d = (adj["adj"] ?? 16667) / 1e5 * Math.min(w, h);
+    return `<polygon points="0,0 ${w - d},0 ${w},${d} ${w},${h} 0,${h}"/>`;
+  },
+  snip2SameRect: (w, h, adj) => {
+    const d = (adj["adj1"] ?? 16667) / 1e5 * Math.min(w, h);
+    const d2 = (adj["adj2"] ?? 0) / 1e5 * Math.min(w, h);
+    return `<polygon points="${d},0 ${w - d},0 ${w},${d} ${w},${h - d2} ${w - d2},${h} ${d2},${h} 0,${h - d2} 0,${d}"/>`;
+  },
+  snip2DiagRect: (w, h, adj) => {
+    const d1 = (adj["adj1"] ?? 16667) / 1e5 * Math.min(w, h);
+    const d2 = (adj["adj2"] ?? 0) / 1e5 * Math.min(w, h);
+    return `<polygon points="${d1},0 ${w},0 ${w},${h - d2} ${w - d2},${h} 0,${h} 0,${d1}"/>`;
+  },
+  snipRoundRect: (w, h, adj) => {
+    const r = (adj["adj1"] ?? 16667) / 1e5 * Math.min(w, h);
+    const d = (adj["adj2"] ?? 16667) / 1e5 * Math.min(w, h);
+    return `<path d="M ${r} 0 L ${w - d} 0 L ${w} ${d} L ${w} ${h} L 0 ${h} L 0 ${r} A ${r} ${r} 0 0 1 ${r} 0 Z"/>`;
+  },
+  round1Rect: (w, h, adj) => {
+    const r = (adj["adj"] ?? 16667) / 1e5 * Math.min(w, h);
+    return `<path d="M 0 0 L ${w - r} 0 A ${r} ${r} 0 0 1 ${w} ${r} L ${w} ${h} L 0 ${h} Z"/>`;
+  },
+  round2SameRect: (w, h, adj) => {
+    const r1 = (adj["adj1"] ?? 16667) / 1e5 * Math.min(w, h);
+    const r2 = (adj["adj2"] ?? 0) / 1e5 * Math.min(w, h);
+    return `<path d="M ${r1} 0 L ${w - r1} 0 A ${r1} ${r1} 0 0 1 ${w} ${r1} L ${w} ${h - r2} A ${r2} ${r2} 0 0 1 ${w - r2} ${h} L ${r2} ${h} A ${r2} ${r2} 0 0 1 0 ${h - r2} L 0 ${r1} A ${r1} ${r1} 0 0 1 ${r1} 0 Z"/>`;
+  },
+  round2DiagRect: (w, h, adj) => {
+    const r1 = (adj["adj1"] ?? 16667) / 1e5 * Math.min(w, h);
+    const r2 = (adj["adj2"] ?? 0) / 1e5 * Math.min(w, h);
+    return `<path d="M ${r1} 0 L ${w} 0 L ${w} ${h - r2} A ${r2} ${r2} 0 0 1 ${w - r2} ${h} L 0 ${h} L 0 ${r1} A ${r1} ${r1} 0 0 1 ${r1} 0 Z"/>`;
+  },
+  // Brackets and braces
+  leftBracket: (w, h, adj) => {
+    const r = (adj["adj"] ?? 8333) / 1e5 * h;
+    return `<path d="M ${w} 0 L ${r} 0 A ${r} ${r} 0 0 0 0 ${r} L 0 ${h - r} A ${r} ${r} 0 0 0 ${r} ${h} L ${w} ${h}"/>`;
+  },
+  rightBracket: (w, h, adj) => {
+    const r = (adj["adj"] ?? 8333) / 1e5 * h;
+    return `<path d="M 0 0 L ${w - r} 0 A ${r} ${r} 0 0 1 ${w} ${r} L ${w} ${h - r} A ${r} ${r} 0 0 1 ${w - r} ${h} L 0 ${h}"/>`;
+  },
+  leftBrace: (w, h, adj) => {
+    const r = (adj["adj1"] ?? 8333) / 1e5 * h;
+    const mid = (adj["adj2"] ?? 5e4) / 1e5 * h;
+    return `<path d="M ${w} 0 A ${w / 2} ${r} 0 0 0 ${w / 2} ${r} L ${w / 2} ${mid - r} A ${w / 2} ${r} 0 0 1 0 ${mid} A ${w / 2} ${r} 0 0 1 ${w / 2} ${mid + r} L ${w / 2} ${h - r} A ${w / 2} ${r} 0 0 0 ${w} ${h}"/>`;
+  },
+  rightBrace: (w, h, adj) => {
+    const r = (adj["adj1"] ?? 8333) / 1e5 * h;
+    const mid = (adj["adj2"] ?? 5e4) / 1e5 * h;
+    return `<path d="M 0 0 A ${w / 2} ${r} 0 0 1 ${w / 2} ${r} L ${w / 2} ${mid - r} A ${w / 2} ${r} 0 0 0 ${w} ${mid} A ${w / 2} ${r} 0 0 0 ${w / 2} ${mid + r} L ${w / 2} ${h - r} A ${w / 2} ${r} 0 0 1 0 ${h}"/>`;
+  },
+  bracketPair: (w, h, adj) => {
+    const r = (adj["adj"] ?? 16667) / 1e5 * Math.min(w, h);
+    return `<path d="M ${r} 0 A ${r} ${r} 0 0 0 0 ${r} L 0 ${h - r} A ${r} ${r} 0 0 0 ${r} ${h} M ${w - r} 0 A ${r} ${r} 0 0 1 ${w} ${r} L ${w} ${h - r} A ${r} ${r} 0 0 1 ${w - r} ${h}"/>`;
+  },
+  bracePair: (w, h, adj) => {
+    const r = (adj["adj"] ?? 8333) / 1e5 * Math.min(w, h);
+    return `<path d="M ${r} 0 A ${r} ${r} 0 0 0 0 ${r} L 0 ${h / 2 - r} A ${r} ${r} 0 0 1 ${-r} ${h / 2} A ${r} ${r} 0 0 1 0 ${h / 2 + r} L 0 ${h - r} A ${r} ${r} 0 0 0 ${r} ${h} M ${w - r} 0 A ${r} ${r} 0 0 1 ${w} ${r} L ${w} ${h / 2 - r} A ${r} ${r} 0 0 0 ${w + r} ${h / 2} A ${r} ${r} 0 0 0 ${w} ${h / 2 + r} L ${w} ${h - r} A ${r} ${r} 0 0 1 ${w - r} ${h}"/>`;
+  },
+  // Other misc shapes
+  lightningBolt: (w, h) => `<polygon points="${w * 0.55},0 ${w * 0.3},${h * 0.4} ${w * 0.52},${h * 0.4} ${w * 0.25},${h} ${w * 0.75},${h * 0.5} ${w * 0.52},${h * 0.5} ${w * 0.85},0"/>`,
+  moon: (w, h, adj) => {
+    const t = (adj["adj"] ?? 5e4) / 1e5 * w;
+    const rx = w / 2;
+    const ry = h / 2;
+    const irx = t / 2;
+    return `<path d="M ${w} 0 A ${rx} ${ry} 0 1 0 ${w} ${h} A ${irx} ${ry} 0 1 1 ${w} 0 Z"/>`;
+  },
+  teardrop: (w, h, adj) => {
+    const d = (adj["adj"] ?? 1e5) / 1e5 * Math.min(w, h) * 0.5;
+    const rx = w / 2;
+    const ry = h / 2;
+    const cx = rx;
+    const cy = ry;
+    return `<path d="M ${cx} 0 L ${cx + d} 0 L ${w} ${cy - d + ry} A ${rx} ${ry} 0 1 1 ${cx} 0 Z"/>`;
+  },
+  sun: (w, h) => {
+    const cx = w / 2;
+    const cy = h / 2;
+    const points = [];
+    for (let i = 0; i < 16; i++) {
+      const angle = Math.PI * 2 * i / 16 - Math.PI / 2;
+      const r = i % 2 === 0 ? 1 : 0.7;
+      points.push(`${cx + cx * r * Math.cos(angle)},${cy + cy * r * Math.sin(angle)}`);
+    }
+    const circleR = 0.4;
+    return `<path d="M ${points.map((p, i) => i === 0 ? `${p}` : ` L ${p}`).join("")} Z M ${cx + cx * circleR} ${cy} A ${cx * circleR} ${cy * circleR} 0 1 0 ${cx - cx * circleR} ${cy} A ${cx * circleR} ${cy * circleR} 0 1 0 ${cx + cx * circleR} ${cy} Z"/>`;
+  },
+  wave: (w, h, adj) => {
+    const dy = (adj["adj1"] ?? 12500) / 1e5 * h;
+    const dx = (adj["adj2"] ?? 0) / 1e5 * w;
+    return `<path d="M ${dx} ${dy} C ${dx + w * 0.25} 0, ${dx + w * 0.5} 0, ${w} ${dy} L ${w - dx} ${h - dy} C ${w - dx - w * 0.25} ${h}, ${w - dx - w * 0.5} ${h}, 0 ${h - dy} Z"/>`;
+  },
+  doubleWave: (w, h, adj) => {
+    const dy = (adj["adj1"] ?? 6250) / 1e5 * h;
+    const dx = (adj["adj2"] ?? 0) / 1e5 * w;
+    return `<path d="M ${dx} ${dy} C ${dx + w * 0.167} 0, ${dx + w * 0.333} ${dy * 2}, ${w / 2} ${dy} C ${w / 2 + w * 0.167} 0, ${w / 2 + w * 0.333} ${dy * 2}, ${w} ${dy} L ${w - dx} ${h - dy} C ${w - dx - w * 0.167} ${h}, ${w - dx - w * 0.333} ${h - dy * 2}, ${w / 2} ${h - dy} C ${w / 2 - w * 0.167} ${h}, ${w / 2 - w * 0.333} ${h - dy * 2}, 0 ${h - dy} Z"/>`;
+  },
+  ribbon: (w, h, adj) => {
+    const tabH = (adj["adj1"] ?? 16667) / 1e5 * h;
+    const tabW = (adj["adj2"] ?? 5e4) / 1e5 * w;
+    const foldW = tabW * 0.3;
+    return `<path d="M 0 ${tabH} L ${foldW} ${tabH * 1.5} L ${foldW} ${h} L ${tabW} ${h - tabH} L ${w - tabW} ${h - tabH} L ${w - foldW} ${h} L ${w - foldW} ${tabH * 1.5} L ${w} ${tabH} L ${w} 0 L ${w - tabW} 0 L ${w - tabW} ${tabH} L ${tabW} ${tabH} L ${tabW} 0 L 0 0 Z"/>`;
+  },
+  ribbon2: (w, h, adj) => {
+    const tabH = (adj["adj1"] ?? 16667) / 1e5 * h;
+    const tabW = (adj["adj2"] ?? 5e4) / 1e5 * w;
+    const foldW = tabW * 0.3;
+    return `<path d="M 0 ${h - tabH} L ${foldW} ${h - tabH * 1.5} L ${foldW} 0 L ${tabW} ${tabH} L ${w - tabW} ${tabH} L ${w - foldW} 0 L ${w - foldW} ${h - tabH * 1.5} L ${w} ${h - tabH} L ${w} ${h} L ${w - tabW} ${h} L ${w - tabW} ${h - tabH} L ${tabW} ${h - tabH} L ${tabW} ${h} L 0 ${h} Z"/>`;
+  }
+};
+function getPresetGeometrySvg(preset, width, height, adjustValues) {
+  const generator = presetGeometries[preset];
+  if (generator) {
+    return generator(width, height, adjustValues);
+  }
+  return `<rect width="${width}" height="${height}"/>`;
+}
+
+// src/renderer/geometry/geometry-renderer.ts
+function renderGeometry(geometry, width, height) {
+  if (geometry.type === "preset") {
+    return getPresetGeometrySvg(geometry.preset, width, height, geometry.adjustValues);
+  }
+  if (geometry.type === "custom" && geometry.pathData) {
+    return `<path d="${geometry.pathData}"/>`;
+  }
+  return `<rect width="${width}" height="${height}"/>`;
+}
+
+// src/renderer/fill-renderer.ts
+function renderFillAttrs(fill) {
+  if (!fill || fill.type === "none") {
+    return { attrs: `fill="none"`, defs: "" };
+  }
+  if (fill.type === "solid") {
+    const alphaAttr = fill.color.alpha < 1 ? ` fill-opacity="${fill.color.alpha}"` : "";
+    return { attrs: `fill="${fill.color.hex}"${alphaAttr}`, defs: "" };
+  }
+  if (fill.type === "gradient") {
+    const id = `grad-${crypto.randomUUID()}`;
+    const angle = fill.angle;
+    const rad = angle * Math.PI / 180;
+    const x1 = 50 - Math.cos(rad) * 50;
+    const y1 = 50 - Math.sin(rad) * 50;
+    const x2 = 50 + Math.cos(rad) * 50;
+    const y2 = 50 + Math.sin(rad) * 50;
+    const stops = fill.stops.map((s) => {
+      const opacityAttr = s.color.alpha < 1 ? ` stop-opacity="${s.color.alpha}"` : "";
+      return `<stop offset="${s.position * 100}%" stop-color="${s.color.hex}"${opacityAttr}/>`;
+    }).join("");
+    const defs = `<linearGradient id="${id}" x1="${x1}%" y1="${y1}%" x2="${x2}%" y2="${y2}%">${stops}</linearGradient>`;
+    return { attrs: `fill="url(#${id})"`, defs };
+  }
+  return { attrs: `fill="none"`, defs: "" };
+}
+function renderOutlineAttrs(outline) {
+  if (!outline) return `stroke="none"`;
+  const widthPx = emuToPixels(outline.width);
+  const parts = [`stroke-width="${widthPx}"`];
+  if (outline.fill) {
+    parts.push(`stroke="${outline.fill.color.hex}"`);
+    if (outline.fill.color.alpha < 1) {
+      parts.push(`stroke-opacity="${outline.fill.color.alpha}"`);
+    }
+  } else {
+    parts.push(`stroke="none"`);
+  }
+  if (outline.dashStyle !== "solid") {
+    const dashArray = getDashArray(outline.dashStyle, widthPx);
+    if (dashArray) {
+      parts.push(`stroke-dasharray="${dashArray}"`);
+    }
+  }
+  return parts.join(" ");
+}
+function getDashArray(style, w) {
+  const patterns = {
+    dash: [4, 3],
+    dot: [1, 3],
+    dashDot: [4, 3, 1, 3],
+    lgDash: [8, 3],
+    lgDashDot: [8, 3, 1, 3],
+    sysDash: [3, 1],
+    sysDot: [1, 1]
+  };
+  const pattern = patterns[style];
+  if (!pattern) return null;
+  return pattern.map((v) => v * w).join(" ");
+}
+
+// src/data/font-metrics.ts
+var metricsData = {
+  Carlito: {
+    unitsPerEm: 2048,
+    ascender: 1950,
+    descender: -550,
+    defaultWidth: 991,
+    cjkWidth: 2048,
+    widths: {
+      " ": 463,
+      "!": 667,
+      '"': 821,
+      "#": 1020,
+      "$": 1038,
+      "%": 1464,
+      "&": 1397,
+      "'": 452,
+      "(": 621,
+      ")": 621,
+      "*": 1020,
+      "+": 1020,
+      ",": 511,
+      "-": 627,
+      ".": 517,
+      "/": 791,
+      "0": 1038,
+      "1": 1038,
+      "2": 1038,
+      "3": 1038,
+      "4": 1038,
+      "5": 1038,
+      "6": 1038,
+      "7": 1038,
+      "8": 1038,
+      "9": 1038,
+      ":": 548,
+      ";": 548,
+      "<": 1020,
+      "=": 1020,
+      ">": 1020,
+      "?": 949,
+      "@": 1831,
+      "A": 1185,
+      "B": 1114,
+      "C": 1092,
+      "D": 1260,
+      "E": 1e3,
+      "F": 941,
+      "G": 1292,
+      "H": 1276,
+      "I": 516,
+      "J": 653,
+      "K": 1064,
+      "L": 861,
+      "M": 1751,
+      "N": 1322,
+      "O": 1356,
+      "P": 1058,
+      "Q": 1378,
+      "R": 1112,
+      "S": 941,
+      "T": 998,
+      "U": 1314,
+      "V": 1162,
+      "W": 1822,
+      "X": 1063,
+      "Y": 998,
+      "Z": 959,
+      "[": 628,
+      "\\": 791,
+      "]": 628,
+      "^": 1020,
+      "_": 1020,
+      "`": 596,
+      "a": 981,
+      "b": 1076,
+      "c": 866,
+      "d": 1076,
+      "e": 1019,
+      "f": 625,
+      "g": 964,
+      "h": 1076,
+      "i": 470,
+      "j": 490,
+      "k": 931,
+      "l": 470,
+      "m": 1636,
+      "n": 1076,
+      "o": 1080,
+      "p": 1076,
+      "q": 1076,
+      "r": 714,
+      "s": 801,
+      "t": 686,
+      "u": 1076,
+      "v": 925,
+      "w": 1464,
+      "x": 887,
+      "y": 927,
+      "z": 809,
+      "{": 644,
+      "|": 943,
+      "}": 644,
+      "~": 1020,
+      "\xA0": 463,
+      "\xA1": 667,
+      "\xA2": 1020,
+      "\xA3": 1038,
+      "\xA4": 1020,
+      "\xA5": 1038,
+      "\xA6": 1020,
+      "\xA7": 1020,
+      "\xA8": 804,
+      "\xA9": 1709,
+      "\xAA": 824,
+      "\xAB": 1049,
+      "\xAC": 1020,
+      "\xAE": 1038,
+      "\xAF": 807,
+      "\xB0": 694,
+      "\xB1": 1020,
+      "\xB2": 688,
+      "\xB3": 685,
+      "\xB4": 598,
+      "\xB5": 1126,
+      "\xB6": 1200,
+      "\xB7": 517,
+      "\xB8": 629,
+      "\xB9": 504,
+      "\xBA": 865,
+      "\xBB": 1049,
+      "\xBC": 1303,
+      "\xBD": 1375,
+      "\xBE": 1383,
+      "\xBF": 949,
+      "\xC0": 1185,
+      "\xC1": 1185,
+      "\xC2": 1185,
+      "\xC3": 1185,
+      "\xC4": 1185,
+      "\xC5": 1185,
+      "\xC6": 1563,
+      "\xC7": 1092,
+      "\xC8": 1e3,
+      "\xC9": 1e3,
+      "\xCA": 1e3,
+      "\xCB": 1e3,
+      "\xCC": 516,
+      "\xCD": 516,
+      "\xCE": 516,
+      "\xCF": 516,
+      "\xD0": 1279,
+      "\xD1": 1322,
+      "\xD2": 1356,
+      "\xD3": 1356,
+      "\xD4": 1356,
+      "\xD5": 1356,
+      "\xD6": 1356,
+      "\xD7": 1020,
+      "\xD8": 1359,
+      "\xD9": 1314,
+      "\xDA": 1314,
+      "\xDB": 1314,
+      "\xDC": 1314,
+      "\xDD": 998,
+      "\xDE": 1058,
+      "\xDF": 1080,
+      "\xE0": 981,
+      "\xE1": 981,
+      "\xE2": 981,
+      "\xE3": 981,
+      "\xE4": 981,
+      "\xE5": 981,
+      "\xE6": 1583,
+      "\xE7": 866,
+      "\xE8": 1019,
+      "\xE9": 1019,
+      "\xEA": 1019,
+      "\xEB": 1019,
+      "\xEC": 470,
+      "\xED": 470,
+      "\xEE": 470,
+      "\xEF": 470,
+      "\xF0": 1076,
+      "\xF1": 1076,
+      "\xF2": 1080,
+      "\xF3": 1080,
+      "\xF4": 1080,
+      "\xF5": 1080,
+      "\xF6": 1080,
+      "\xF7": 1020,
+      "\xF8": 1084,
+      "\xF9": 1076,
+      "\xFA": 1076,
+      "\xFB": 1076,
+      "\xFC": 1076,
+      "\xFD": 927,
+      "\xFE": 1076,
+      "\xFF": 927
+    }
+  },
+  LiberationSans: {
+    unitsPerEm: 2048,
+    ascender: 1854,
+    descender: -434,
+    defaultWidth: 1114,
+    cjkWidth: 2048,
+    widths: {
+      " ": 569,
+      "!": 569,
+      '"': 727,
+      "#": 1139,
+      "$": 1139,
+      "%": 1821,
+      "&": 1366,
+      "'": 391,
+      "(": 682,
+      ")": 682,
+      "*": 797,
+      "+": 1196,
+      ",": 569,
+      "-": 682,
+      ".": 569,
+      "/": 569,
+      "0": 1139,
+      "1": 1139,
+      "2": 1139,
+      "3": 1139,
+      "4": 1139,
+      "5": 1139,
+      "6": 1139,
+      "7": 1139,
+      "8": 1139,
+      "9": 1139,
+      ":": 569,
+      ";": 569,
+      "<": 1196,
+      "=": 1196,
+      ">": 1196,
+      "?": 1139,
+      "@": 2079,
+      "A": 1366,
+      "B": 1366,
+      "C": 1479,
+      "D": 1479,
+      "E": 1366,
+      "F": 1251,
+      "G": 1593,
+      "H": 1479,
+      "I": 569,
+      "J": 1024,
+      "K": 1366,
+      "L": 1139,
+      "M": 1706,
+      "N": 1479,
+      "O": 1593,
+      "P": 1366,
+      "Q": 1593,
+      "R": 1479,
+      "S": 1366,
+      "T": 1251,
+      "U": 1479,
+      "V": 1366,
+      "W": 1933,
+      "X": 1366,
+      "Y": 1366,
+      "Z": 1251,
+      "[": 569,
+      "\\": 569,
+      "]": 569,
+      "^": 961,
+      "_": 1139,
+      "`": 682,
+      "a": 1139,
+      "b": 1139,
+      "c": 1024,
+      "d": 1139,
+      "e": 1139,
+      "f": 569,
+      "g": 1139,
+      "h": 1139,
+      "i": 455,
+      "j": 455,
+      "k": 1024,
+      "l": 455,
+      "m": 1706,
+      "n": 1139,
+      "o": 1139,
+      "p": 1139,
+      "q": 1139,
+      "r": 682,
+      "s": 1024,
+      "t": 569,
+      "u": 1139,
+      "v": 1024,
+      "w": 1479,
+      "x": 1024,
+      "y": 1024,
+      "z": 1024,
+      "{": 684,
+      "|": 532,
+      "}": 684,
+      "~": 1196,
+      "\xA0": 569,
+      "\xA1": 682,
+      "\xA2": 1139,
+      "\xA3": 1139,
+      "\xA4": 1139,
+      "\xA5": 1139,
+      "\xA6": 532,
+      "\xA7": 1139,
+      "\xA8": 682,
+      "\xA9": 1509,
+      "\xAA": 758,
+      "\xAB": 1139,
+      "\xAC": 1196,
+      "\xAD": 682,
+      "\xAE": 1509,
+      "\xAF": 1131,
+      "\xB0": 819,
+      "\xB1": 1124,
+      "\xB2": 682,
+      "\xB3": 682,
+      "\xB4": 682,
+      "\xB5": 1180,
+      "\xB6": 1100,
+      "\xB7": 682,
+      "\xB8": 682,
+      "\xB9": 682,
+      "\xBA": 748,
+      "\xBB": 1139,
+      "\xBC": 1708,
+      "\xBD": 1708,
+      "\xBE": 1708,
+      "\xBF": 1251,
+      "\xC0": 1366,
+      "\xC1": 1366,
+      "\xC2": 1366,
+      "\xC3": 1366,
+      "\xC4": 1366,
+      "\xC5": 1366,
+      "\xC6": 2048,
+      "\xC7": 1479,
+      "\xC8": 1366,
+      "\xC9": 1366,
+      "\xCA": 1366,
+      "\xCB": 1366,
+      "\xCC": 569,
+      "\xCD": 569,
+      "\xCE": 569,
+      "\xCF": 569,
+      "\xD0": 1479,
+      "\xD1": 1479,
+      "\xD2": 1593,
+      "\xD3": 1593,
+      "\xD4": 1593,
+      "\xD5": 1593,
+      "\xD6": 1593,
+      "\xD7": 1196,
+      "\xD8": 1593,
+      "\xD9": 1479,
+      "\xDA": 1479,
+      "\xDB": 1479,
+      "\xDC": 1479,
+      "\xDD": 1366,
+      "\xDE": 1366,
+      "\xDF": 1251,
+      "\xE0": 1139,
+      "\xE1": 1139,
+      "\xE2": 1139,
+      "\xE3": 1139,
+      "\xE4": 1139,
+      "\xE5": 1139,
+      "\xE6": 1821,
+      "\xE7": 1024,
+      "\xE8": 1139,
+      "\xE9": 1139,
+      "\xEA": 1139,
+      "\xEB": 1139,
+      "\xEC": 569,
+      "\xED": 569,
+      "\xEE": 569,
+      "\xEF": 569,
+      "\xF0": 1139,
+      "\xF1": 1139,
+      "\xF2": 1139,
+      "\xF3": 1139,
+      "\xF4": 1139,
+      "\xF5": 1139,
+      "\xF6": 1139,
+      "\xF7": 1124,
+      "\xF8": 1251,
+      "\xF9": 1139,
+      "\xFA": 1139,
+      "\xFB": 1139,
+      "\xFC": 1139,
+      "\xFD": 1024,
+      "\xFE": 1139,
+      "\xFF": 1024
+    }
+  },
+  LiberationSerif: {
+    unitsPerEm: 2048,
+    ascender: 1825,
+    descender: -443,
+    defaultWidth: 1056,
+    cjkWidth: 2048,
+    widths: {
+      " ": 512,
+      "!": 682,
+      '"': 836,
+      "#": 1024,
+      "$": 1024,
+      "%": 1706,
+      "&": 1593,
+      "'": 369,
+      "(": 682,
+      ")": 682,
+      "*": 1024,
+      "+": 1155,
+      ",": 512,
+      "-": 682,
+      ".": 512,
+      "/": 569,
+      "0": 1024,
+      "1": 1024,
+      "2": 1024,
+      "3": 1024,
+      "4": 1024,
+      "5": 1024,
+      "6": 1024,
+      "7": 1024,
+      "8": 1024,
+      "9": 1024,
+      ":": 569,
+      ";": 569,
+      "<": 1155,
+      "=": 1155,
+      ">": 1155,
+      "?": 909,
+      "@": 1886,
+      "A": 1479,
+      "B": 1366,
+      "C": 1366,
+      "D": 1479,
+      "E": 1251,
+      "F": 1139,
+      "G": 1479,
+      "H": 1479,
+      "I": 682,
+      "J": 797,
+      "K": 1479,
+      "L": 1251,
+      "M": 1821,
+      "N": 1479,
+      "O": 1479,
+      "P": 1139,
+      "Q": 1479,
+      "R": 1366,
+      "S": 1139,
+      "T": 1251,
+      "U": 1479,
+      "V": 1479,
+      "W": 1933,
+      "X": 1479,
+      "Y": 1479,
+      "Z": 1251,
+      "[": 682,
+      "\\": 569,
+      "]": 682,
+      "^": 961,
+      "_": 1024,
+      "`": 682,
+      "a": 909,
+      "b": 1024,
+      "c": 909,
+      "d": 1024,
+      "e": 909,
+      "f": 682,
+      "g": 1024,
+      "h": 1024,
+      "i": 569,
+      "j": 569,
+      "k": 1024,
+      "l": 569,
+      "m": 1593,
+      "n": 1024,
+      "o": 1024,
+      "p": 1024,
+      "q": 1024,
+      "r": 682,
+      "s": 797,
+      "t": 569,
+      "u": 1024,
+      "v": 1024,
+      "w": 1479,
+      "x": 1024,
+      "y": 1024,
+      "z": 909,
+      "{": 983,
+      "|": 410,
+      "}": 983,
+      "~": 1108,
+      "\xA0": 512,
+      "\xA1": 682,
+      "\xA2": 1024,
+      "\xA3": 1024,
+      "\xA4": 1024,
+      "\xA5": 1024,
+      "\xA6": 410,
+      "\xA7": 1024,
+      "\xA8": 682,
+      "\xA9": 1556,
+      "\xAA": 565,
+      "\xAB": 1024,
+      "\xAC": 1155,
+      "\xAD": 682,
+      "\xAE": 1556,
+      "\xAF": 1024,
+      "\xB0": 819,
+      "\xB1": 1124,
+      "\xB2": 614,
+      "\xB3": 614,
+      "\xB4": 682,
+      "\xB5": 1180,
+      "\xB6": 928,
+      "\xB7": 682,
+      "\xB8": 682,
+      "\xB9": 614,
+      "\xBA": 635,
+      "\xBB": 1024,
+      "\xBC": 1536,
+      "\xBD": 1536,
+      "\xBE": 1536,
+      "\xBF": 909,
+      "\xC0": 1479,
+      "\xC1": 1479,
+      "\xC2": 1479,
+      "\xC3": 1479,
+      "\xC4": 1479,
+      "\xC5": 1479,
+      "\xC6": 1821,
+      "\xC7": 1366,
+      "\xC8": 1251,
+      "\xC9": 1251,
+      "\xCA": 1251,
+      "\xCB": 1251,
+      "\xCC": 682,
+      "\xCD": 682,
+      "\xCE": 682,
+      "\xCF": 682,
+      "\xD0": 1479,
+      "\xD1": 1479,
+      "\xD2": 1479,
+      "\xD3": 1479,
+      "\xD4": 1479,
+      "\xD5": 1479,
+      "\xD6": 1479,
+      "\xD7": 1155,
+      "\xD8": 1479,
+      "\xD9": 1479,
+      "\xDA": 1479,
+      "\xDB": 1479,
+      "\xDC": 1479,
+      "\xDD": 1479,
+      "\xDE": 1139,
+      "\xDF": 1024,
+      "\xE0": 909,
+      "\xE1": 909,
+      "\xE2": 909,
+      "\xE3": 909,
+      "\xE4": 909,
+      "\xE5": 909,
+      "\xE6": 1366,
+      "\xE7": 909,
+      "\xE8": 909,
+      "\xE9": 909,
+      "\xEA": 909,
+      "\xEB": 909,
+      "\xEC": 569,
+      "\xED": 569,
+      "\xEE": 569,
+      "\xEF": 569,
+      "\xF0": 1024,
+      "\xF1": 1024,
+      "\xF2": 1024,
+      "\xF3": 1024,
+      "\xF4": 1024,
+      "\xF5": 1024,
+      "\xF6": 1024,
+      "\xF7": 1124,
+      "\xF8": 1024,
+      "\xF9": 1024,
+      "\xFA": 1024,
+      "\xFB": 1024,
+      "\xFC": 1024,
+      "\xFD": 1024,
+      "\xFE": 1024,
+      "\xFF": 1024
+    }
+  },
+  NotoSansJP: {
+    unitsPerEm: 1e3,
+    ascender: 1160,
+    descender: -288,
+    defaultWidth: 563,
+    cjkWidth: 1e3,
+    widths: {
+      " ": 224,
+      "!": 323,
+      '"': 474,
+      "#": 555,
+      "$": 555,
+      "%": 921,
+      "&": 680,
+      "'": 278,
+      "(": 338,
+      ")": 338,
+      "*": 467,
+      "+": 555,
+      ",": 278,
+      "-": 347,
+      ".": 278,
+      "/": 392,
+      "0": 555,
+      "1": 555,
+      "2": 555,
+      "3": 555,
+      "4": 555,
+      "5": 555,
+      "6": 555,
+      "7": 555,
+      "8": 555,
+      "9": 555,
+      ":": 278,
+      ";": 278,
+      "<": 555,
+      "=": 555,
+      ">": 555,
+      "?": 474,
+      "@": 946,
+      "A": 608,
+      "B": 657,
+      "C": 638,
+      "D": 688,
+      "E": 589,
+      "F": 552,
+      "G": 689,
+      "H": 728,
+      "I": 293,
+      "J": 535,
+      "K": 646,
+      "L": 543,
+      "M": 812,
+      "N": 723,
+      "O": 742,
+      "P": 633,
+      "Q": 742,
+      "R": 635,
+      "S": 596,
+      "T": 599,
+      "U": 721,
+      "V": 575,
+      "W": 878,
+      "X": 573,
+      "Y": 531,
+      "Z": 603,
+      "[": 338,
+      "\\": 392,
+      "]": 338,
+      "^": 555,
+      "_": 559,
+      "`": 606,
+      "a": 563,
+      "b": 618,
+      "c": 510,
+      "d": 620,
+      "e": 554,
+      "f": 325,
+      "g": 564,
+      "h": 607,
+      "i": 275,
+      "j": 275,
+      "k": 552,
+      "l": 284,
+      "m": 926,
+      "n": 610,
+      "o": 606,
+      "p": 620,
+      "q": 620,
+      "r": 388,
+      "s": 468,
+      "t": 377,
+      "u": 607,
+      "v": 521,
+      "w": 802,
+      "x": 498,
+      "y": 521,
+      "z": 475,
+      "{": 338,
+      "|": 270,
+      "}": 338,
+      "~": 555,
+      "\xA0": 224,
+      "\xA1": 323,
+      "\xA2": 555,
+      "\xA3": 555,
+      "\xA4": 555,
+      "\xA5": 555,
+      "\xA6": 270,
+      "\xA7": 1e3,
+      "\xA8": 606,
+      "\xA9": 832,
+      "\xAA": 386,
+      "\xAB": 479,
+      "\xAC": 555,
+      "\xAD": 347,
+      "\xAE": 473,
+      "\xAF": 606,
+      "\xB0": 370,
+      "\xB1": 1e3,
+      "\xB2": 411,
+      "\xB3": 411,
+      "\xB4": 606,
+      "\xB5": 628,
+      "\xB6": 1e3,
+      "\xB7": 561,
+      "\xB8": 606,
+      "\xB9": 411,
+      "\xBA": 407,
+      "\xBB": 479,
+      "\xBC": 873,
+      "\xBD": 903,
+      "\xBE": 889,
+      "\xBF": 474,
+      "\xC0": 608,
+      "\xC1": 608,
+      "\xC2": 608,
+      "\xC3": 608,
+      "\xC4": 608,
+      "\xC5": 608,
+      "\xC6": 918,
+      "\xC7": 638,
+      "\xC8": 589,
+      "\xC9": 589,
+      "\xCA": 589,
+      "\xCB": 589,
+      "\xCC": 293,
+      "\xCD": 293,
+      "\xCE": 293,
+      "\xCF": 293,
+      "\xD0": 712,
+      "\xD1": 723,
+      "\xD2": 742,
+      "\xD3": 742,
+      "\xD4": 742,
+      "\xD5": 742,
+      "\xD6": 742,
+      "\xD7": 1e3,
+      "\xD8": 742,
+      "\xD9": 721,
+      "\xDA": 721,
+      "\xDB": 721,
+      "\xDC": 721,
+      "\xDD": 531,
+      "\xDE": 652,
+      "\xDF": 643,
+      "\xE0": 563,
+      "\xE1": 563,
+      "\xE2": 563,
+      "\xE3": 563,
+      "\xE4": 563,
+      "\xE5": 563,
+      "\xE6": 877,
+      "\xE7": 510,
+      "\xE8": 554,
+      "\xE9": 554,
+      "\xEA": 554,
+      "\xEB": 554,
+      "\xEC": 275,
+      "\xED": 275,
+      "\xEE": 275,
+      "\xEF": 275,
+      "\xF0": 608,
+      "\xF1": 610,
+      "\xF2": 606,
+      "\xF3": 606,
+      "\xF4": 606,
+      "\xF5": 606,
+      "\xF6": 606,
+      "\xF7": 1e3,
+      "\xF8": 606,
+      "\xF9": 607,
+      "\xFA": 607,
+      "\xFB": 607,
+      "\xFC": 607,
+      "\xFD": 521,
+      "\xFE": 620,
+      "\xFF": 521
+    }
+  }
+};
+var fontNameMap = {
+  // Calibri → Carlito
+  Calibri: "Carlito",
+  calibri: "Carlito",
+  // Arial / Helvetica → Liberation Sans
+  Arial: "LiberationSans",
+  arial: "LiberationSans",
+  Helvetica: "LiberationSans",
+  helvetica: "LiberationSans",
+  // Times New Roman → Liberation Serif
+  "Times New Roman": "LiberationSerif",
+  "times new roman": "LiberationSerif",
+  // 日本語フォント → Noto Sans JP
+  "MS PGothic": "NotoSansJP",
+  "MS P\u30B4\u30B7\u30C3\u30AF": "NotoSansJP",
+  "MS Gothic": "NotoSansJP",
+  "MS \u30B4\u30B7\u30C3\u30AF": "NotoSansJP",
+  Meiryo: "NotoSansJP",
+  \u30E1\u30A4\u30EA\u30AA: "NotoSansJP",
+  "Yu Gothic": "NotoSansJP",
+  \u6E38\u30B4\u30B7\u30C3\u30AF: "NotoSansJP",
+  "Yu Mincho": "NotoSansJP",
+  \u6E38\u660E\u671D: "NotoSansJP",
+  "Hiragino Sans": "NotoSansJP",
+  "Hiragino Kaku Gothic ProN": "NotoSansJP",
+  "Noto Sans JP": "NotoSansJP",
+  "Noto Sans CJK JP": "NotoSansJP"
+};
+var metricsKeyToFontName = {
+  Carlito: "Carlito",
+  LiberationSans: "Liberation Sans",
+  LiberationSerif: "Liberation Serif",
+  NotoSansJP: "Noto Sans JP"
+};
+function getFontMetrics(fontFamily) {
+  if (!fontFamily) return null;
+  const key = fontNameMap[fontFamily] ?? fontNameMap[fontFamily.toLowerCase()];
+  if (!key) return null;
+  return metricsData[key] ?? null;
+}
+function getMetricsFallbackFont(fontFamily) {
+  if (!fontFamily) return null;
+  const key = fontNameMap[fontFamily] ?? fontNameMap[fontFamily.toLowerCase()];
+  if (!key) return null;
+  return metricsKeyToFontName[key] ?? null;
+}
+
+// src/utils/text-measure.ts
+var WIDTH_RATIO = {
+  narrow: 0.3,
+  normal: 0.6,
+  wide: 1
+};
+var BOLD_FACTOR = 1.05;
+var PX_PER_PT = 96 / 72;
+var DEFAULT_LINE_HEIGHT_RATIO = 1.2;
+function getLineHeightRatio(fontFamily, fontFamilyEa) {
+  const metrics = getFontMetrics(fontFamily) ?? getFontMetrics(fontFamilyEa);
+  if (!metrics) return DEFAULT_LINE_HEIGHT_RATIO;
+  return (metrics.ascender + Math.abs(metrics.descender)) / metrics.unitsPerEm;
+}
+function isCjkCodePoint(codePoint) {
+  return codePoint >= 12288 && codePoint <= 40959 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 131072 && codePoint <= 173791;
+}
+function categorizeChar(codePoint) {
+  if (isCjkCodePoint(codePoint)) {
+    return "wide";
+  }
+  if (codePoint === 32 || // space
+  codePoint === 33 || // !
+  codePoint === 44 || // ,
+  codePoint === 46 || // .
+  codePoint === 58 || // :
+  codePoint === 59 || // ;
+  codePoint === 105 || // i
+  codePoint === 106 || // j
+  codePoint === 108 || // l
+  codePoint === 49 || // 1
+  codePoint === 124 || // |
+  codePoint === 39 || // '
+  codePoint === 40 || // (
+  codePoint === 41 || // )
+  codePoint === 91 || // [
+  codePoint === 93 || // ]
+  codePoint === 123 || // {
+  codePoint === 125) {
+    return "narrow";
+  }
+  return "normal";
+}
+function measureCharHeuristic(codePoint, baseSizePx) {
+  return baseSizePx * WIDTH_RATIO[categorizeChar(codePoint)];
+}
+function measureCharMetrics(char, codePoint, baseSizePx, metrics) {
+  const charWidth = metrics.widths[char];
+  if (charWidth !== void 0) {
+    return charWidth / metrics.unitsPerEm * baseSizePx;
+  }
+  if (isCjkCodePoint(codePoint)) {
+    return metrics.cjkWidth / metrics.unitsPerEm * baseSizePx;
+  }
+  return metrics.defaultWidth / metrics.unitsPerEm * baseSizePx;
+}
+function measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa) {
+  const baseSizePx = fontSizePt * PX_PER_PT;
+  const latinMetrics = getFontMetrics(fontFamily);
+  const eaMetrics = getFontMetrics(fontFamilyEa);
+  let totalWidth = 0;
+  for (const char of text) {
+    const codePoint = char.codePointAt(0);
+    const isEa = isCjkCodePoint(codePoint);
+    const metrics = isEa && eaMetrics ? eaMetrics : latinMetrics;
+    if (metrics) {
+      totalWidth += measureCharMetrics(char, codePoint, baseSizePx, metrics);
+    } else {
+      totalWidth += measureCharHeuristic(codePoint, baseSizePx);
+    }
+  }
+  if (bold) {
+    totalWidth *= BOLD_FACTOR;
+  }
+  return totalWidth;
+}
+
+// src/utils/text-wrap.ts
+var DEFAULT_FONT_SIZE = 18;
+function isCjk(codePoint) {
+  return codePoint >= 12288 && codePoint <= 40959 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 131072 && codePoint <= 173791;
+}
+function isWhitespace(codePoint) {
+  return codePoint === 32 || codePoint === 9 || codePoint === 10 || codePoint === 13;
+}
+function splitTextIntoFragments(text) {
+  const fragments = [];
+  let current = "";
+  let currentType = null;
+  for (const char of text) {
+    const cp = char.codePointAt(0);
+    if (isWhitespace(cp)) {
+      if (current && currentType !== "space") {
+        fragments.push({ fragment: current, breakable: currentType === "cjk" });
+        current = "";
+      }
+      currentType = "space";
+      current += char;
+    } else if (isCjk(cp)) {
+      if (current) {
+        fragments.push({
+          fragment: current,
+          breakable: currentType === "cjk" || currentType === "space"
+        });
+        current = "";
+      }
+      fragments.push({ fragment: char, breakable: true });
+      currentType = "cjk";
+      current = "";
+    } else {
+      if (current && currentType !== "latin") {
+        fragments.push({ fragment: current, breakable: currentType === "space" });
+        current = "";
+      }
+      currentType = "latin";
+      current += char;
+    }
+  }
+  if (current) {
+    fragments.push({
+      fragment: current,
+      breakable: currentType === "space" || currentType === "cjk"
+    });
+  }
+  return fragments;
+}
+function tokenizeRuns(runs, defaultFontSize, fontScale) {
+  const tokens = [];
+  let isFirst = true;
+  for (const run of runs) {
+    if (run.text.length === 0) continue;
+    const fontSize = run.properties.fontSize ? run.properties.fontSize * fontScale : defaultFontSize;
+    const bold = run.properties.bold;
+    const fontFamily = run.properties.fontFamily;
+    const fontFamilyEa = run.properties.fontFamilyEa;
+    const fragments = splitTextIntoFragments(run.text);
+    for (const { fragment, breakable } of fragments) {
+      const width = measureTextWidth(fragment, fontSize, bold, fontFamily, fontFamilyEa);
+      tokens.push({
+        text: fragment,
+        properties: run.properties,
+        width,
+        breakable: isFirst ? false : breakable
+      });
+      isFirst = false;
+    }
+  }
+  return tokens;
+}
+function isSpaceOnly(text) {
+  for (const char of text) {
+    if (!isWhitespace(char.codePointAt(0))) return false;
+  }
+  return true;
+}
+function splitTokenByChars(token, availableWidth, defaultFontSize, fontScale) {
+  const lines = [];
+  let currentLine = [];
+  let currentWidth = 0;
+  const fontSize = token.properties.fontSize ? token.properties.fontSize * fontScale : defaultFontSize;
+  const bold = token.properties.bold;
+  const fontFamily = token.properties.fontFamily;
+  const fontFamilyEa = token.properties.fontFamilyEa;
+  for (const char of token.text) {
+    const charWidth = measureTextWidth(char, fontSize, bold, fontFamily, fontFamilyEa);
+    if (currentWidth + charWidth > availableWidth && currentLine.length > 0) {
+      lines.push(currentLine);
+      currentLine = [];
+      currentWidth = 0;
+    }
+    currentLine.push({
+      text: char,
+      properties: token.properties,
+      width: charWidth,
+      breakable: false
+    });
+    currentWidth += charWidth;
+  }
+  if (currentLine.length > 0) {
+    lines.push(currentLine);
+  }
+  return lines;
+}
+function mergeSegments(tokens) {
+  const segments = [];
+  for (const token of tokens) {
+    if (segments.length > 0) {
+      const last = segments[segments.length - 1];
+      if (last.properties === token.properties) {
+        last.text += token.text;
+        continue;
+      }
+    }
+    segments.push({ text: token.text, properties: token.properties });
+  }
+  return segments;
+}
+function trimTrailingSpaces(segments) {
+  if (segments.length === 0) return segments;
+  const last = segments[segments.length - 1];
+  const trimmed = last.text.replace(/\s+$/, "");
+  if (trimmed.length === 0) {
+    const result = segments.slice(0, -1);
+    return trimTrailingSpaces(result);
+  }
+  if (trimmed !== last.text) {
+    return [...segments.slice(0, -1), { text: trimmed, properties: last.properties }];
+  }
+  return segments;
+}
+function layoutTokensIntoLines(tokens, availableWidth, defaultFontSize, fontScale) {
+  if (tokens.length === 0) return [{ segments: [] }];
+  const lines = [];
+  let currentLine = [];
+  let currentWidth = 0;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (currentWidth + token.width <= availableWidth) {
+      currentLine.push(token);
+      currentWidth += token.width;
+    } else if (currentLine.length === 0) {
+      if (isSpaceOnly(token.text)) {
+        continue;
+      }
+      const splitLines = splitTokenByChars(token, availableWidth, defaultFontSize, fontScale);
+      for (let j = 0; j < splitLines.length; j++) {
+        if (j < splitLines.length - 1) {
+          const segments = trimTrailingSpaces(mergeSegments(splitLines[j]));
+          if (segments.length > 0) lines.push({ segments });
+        } else {
+          currentLine = splitLines[j];
+          currentWidth = splitLines[j].reduce((sum, t) => sum + t.width, 0);
+        }
+      }
+    } else if (token.breakable) {
+      const segments = trimTrailingSpaces(mergeSegments(currentLine));
+      if (segments.length > 0) lines.push({ segments });
+      if (isSpaceOnly(token.text)) {
+        currentLine = [];
+        currentWidth = 0;
+      } else {
+        currentLine = [token];
+        currentWidth = token.width;
+      }
+    } else {
+      const segments = trimTrailingSpaces(mergeSegments(currentLine));
+      if (segments.length > 0) lines.push({ segments });
+      currentLine = [token];
+      currentWidth = token.width;
+    }
+  }
+  if (currentLine.length > 0) {
+    const segments = trimTrailingSpaces(mergeSegments(currentLine));
+    if (segments.length > 0) lines.push({ segments });
+  }
+  return lines.length > 0 ? lines : [{ segments: [] }];
+}
+function wrapParagraph(paragraph, availableWidth, defaultFontSize = DEFAULT_FONT_SIZE, fontScale = 1) {
+  if (paragraph.runs.length === 0 || !paragraph.runs.some((r) => r.text.length > 0)) {
+    return [{ segments: [] }];
+  }
+  const safeWidth = Math.max(availableWidth, 1);
+  const tokens = tokenizeRuns(paragraph.runs, defaultFontSize, fontScale);
+  if (tokens.length === 0) return [{ segments: [] }];
+  return layoutTokensIntoLines(tokens, safeWidth, defaultFontSize, fontScale);
+}
+
+// src/renderer/text-renderer.ts
+var PX_PER_PT2 = 96 / 72;
+var DEFAULT_LINE_SPACING = 1;
+var DEFAULT_FONT_SIZE_PT = 18;
+function renderTextBody(textBody, transform) {
+  const { bodyProperties, paragraphs } = textBody;
+  const width = emuToPixels(transform.extentWidth);
+  const height = emuToPixels(transform.extentHeight);
+  const marginLeft = emuToPixels(bodyProperties.marginLeft);
+  const marginRight = emuToPixels(bodyProperties.marginRight);
+  const marginTop = emuToPixels(bodyProperties.marginTop);
+  const marginBottom = emuToPixels(bodyProperties.marginBottom);
+  const hasText = paragraphs.some((p) => p.runs.some((r) => r.text.length > 0));
+  if (!hasText) return "";
+  const textWidth = width - marginLeft - marginRight;
+  const defaultFontSize = getDefaultFontSize(paragraphs);
+  const shouldWrap = bodyProperties.wrap !== "none";
+  const fontScale = bodyProperties.fontScale;
+  const lnSpcReduction = bodyProperties.lnSpcReduction;
+  const scaledDefaultFontSize = defaultFontSize * fontScale;
+  const defaultLineHeightRatio = getDefaultLineHeightRatio(paragraphs);
+  const defaultNaturalHeight = scaledDefaultFontSize * defaultLineHeightRatio;
+  const tspans = [];
+  let isFirstLine = true;
+  const autoNumCounters = /* @__PURE__ */ new Map();
+  for (const para of paragraphs) {
+    const paraMarginLeft = emuToPixels(para.properties.marginLeft);
+    const paraIndent = emuToPixels(para.properties.indent);
+    const textStartX = marginLeft + paraMarginLeft;
+    const bulletX = textStartX + paraIndent;
+    const effectiveTextWidth = textWidth - paraMarginLeft;
+    const bulletText = resolveBulletText(para.properties, autoNumCounters);
+    const { xPos, anchorValue } = getAlignmentInfo(
+      para.properties.alignment,
+      textStartX,
+      effectiveTextWidth,
+      width,
+      marginRight
+    );
+    if (para.runs.length === 0 || !para.runs.some((r) => r.text.length > 0)) {
+      const dy = computeDy(isFirstLine, defaultNaturalHeight, DEFAULT_LINE_SPACING, para, true);
+      tspans.push(`<tspan x="${xPos}" dy="${dy}" text-anchor="${anchorValue}"> </tspan>`);
+      isFirstLine = false;
+      continue;
+    }
+    if (shouldWrap) {
+      const wrappedLines = wrapParagraph(
+        para,
+        effectiveTextWidth,
+        scaledDefaultFontSize,
+        fontScale
+      );
+      for (let lineIdx = 0; lineIdx < wrappedLines.length; lineIdx++) {
+        const line = wrappedLines[lineIdx];
+        if (line.segments.length === 0) {
+          const dy = computeDy(
+            isFirstLine,
+            defaultNaturalHeight,
+            getLineSpacing(para, lnSpcReduction),
+            para,
+            lineIdx === 0
+          );
+          tspans.push(`<tspan x="${xPos}" dy="${dy}" text-anchor="${anchorValue}"> </tspan>`);
+          isFirstLine = false;
+          continue;
+        }
+        if (lineIdx === 0 && bulletText) {
+          const lineFontSize = getLineFontSize(line.segments, defaultFontSize) * fontScale;
+          const lineNaturalHeight = computeLineNaturalHeight(
+            line.segments,
+            defaultFontSize,
+            fontScale
+          );
+          const dy = computeDy(
+            isFirstLine,
+            lineNaturalHeight,
+            getLineSpacing(para, lnSpcReduction),
+            para,
+            true
+          );
+          const bulletStyles = buildBulletStyleAttrs(para.properties, lineFontSize, fontScale);
+          tspans.push(
+            `<tspan x="${bulletX}" dy="${dy}" text-anchor="start" ${bulletStyles}>${escapeXml(bulletText)}</tspan>`
+          );
+          for (let segIdx = 0; segIdx < line.segments.length; segIdx++) {
+            const seg = line.segments[segIdx];
+            const prefix = segIdx === 0 ? `x="${xPos}" text-anchor="${anchorValue}" ` : "";
+            tspans.push(renderSegment(seg.text, seg.properties, fontScale, prefix));
+          }
+        } else {
+          for (let segIdx = 0; segIdx < line.segments.length; segIdx++) {
+            const seg = line.segments[segIdx];
+            if (segIdx === 0) {
+              const lineNaturalHeight = computeLineNaturalHeight(
+                line.segments,
+                defaultFontSize,
+                fontScale
+              );
+              const dy = computeDy(
+                isFirstLine,
+                lineNaturalHeight,
+                getLineSpacing(para, lnSpcReduction),
+                para,
+                lineIdx === 0
+              );
+              const prefix = `x="${xPos}" dy="${dy}" text-anchor="${anchorValue}" `;
+              tspans.push(renderSegment(seg.text, seg.properties, fontScale, prefix));
+            } else {
+              tspans.push(renderSegment(seg.text, seg.properties, fontScale, ""));
+            }
+          }
+        }
+        isFirstLine = false;
+      }
+    } else {
+      let firstRunRendered = false;
+      if (bulletText) {
+        const firstRun = para.runs.find((r) => r.text.length > 0);
+        const fontSize = (firstRun?.properties.fontSize ?? defaultFontSize) * fontScale;
+        const naturalHeight = computeLineNaturalHeight(para.runs, defaultFontSize, fontScale);
+        const dy = computeDy(
+          isFirstLine,
+          naturalHeight,
+          getLineSpacing(para, lnSpcReduction),
+          para,
+          true
+        );
+        const bulletStyles = buildBulletStyleAttrs(para.properties, fontSize, fontScale);
+        tspans.push(
+          `<tspan x="${bulletX}" dy="${dy}" text-anchor="start" ${bulletStyles}>${escapeXml(bulletText)}</tspan>`
+        );
+      }
+      for (let i = 0; i < para.runs.length; i++) {
+        const run = para.runs[i];
+        if (run.text.length === 0) continue;
+        if (!firstRunRendered) {
+          if (bulletText) {
+            const prefix = `x="${xPos}" text-anchor="${anchorValue}" `;
+            tspans.push(renderSegment(run.text, run.properties, fontScale, prefix));
+          } else {
+            const naturalHeight = computeLineNaturalHeight(para.runs, defaultFontSize, fontScale);
+            const dy = computeDy(
+              isFirstLine,
+              naturalHeight,
+              getLineSpacing(para, lnSpcReduction),
+              para,
+              true
+            );
+            const prefix = `x="${xPos}" dy="${dy}" text-anchor="${anchorValue}" `;
+            tspans.push(renderSegment(run.text, run.properties, fontScale, prefix));
+          }
+          firstRunRendered = true;
+        } else {
+          tspans.push(renderSegment(run.text, run.properties, fontScale, ""));
+        }
+      }
+      isFirstLine = false;
+    }
+  }
+  let yStart = marginTop;
+  const totalTextHeight = estimateTextHeight(
+    paragraphs,
+    scaledDefaultFontSize,
+    shouldWrap,
+    textWidth,
+    lnSpcReduction,
+    fontScale
+  );
+  if (bodyProperties.anchor === "ctr") {
+    yStart = Math.max(marginTop, (height - totalTextHeight) / 2);
+  } else if (bodyProperties.anchor === "b") {
+    yStart = Math.max(marginTop, height - totalTextHeight - marginBottom);
+  }
+  yStart += defaultNaturalHeight;
+  return `<text x="0" y="${yStart}">${tspans.join("")}</text>`;
+}
+function resolveBulletText(props, autoNumCounters) {
+  if (!props.bullet) return null;
+  if (props.bullet.type === "none") return null;
+  if (props.bullet.type === "char") {
+    return props.bullet.char;
+  }
+  if (props.bullet.type === "autoNum") {
+    const { scheme, startAt } = props.bullet;
+    const counterKey = `${scheme}-${props.level}`;
+    const current = autoNumCounters.get(counterKey) ?? 0;
+    const nextVal = current + 1;
+    autoNumCounters.set(counterKey, nextVal);
+    const index = startAt + nextVal - 1;
+    return formatAutoNum(scheme, index);
+  }
+  return null;
+}
+function formatAutoNum(scheme, index) {
+  switch (scheme) {
+    case "arabicPeriod":
+      return `${index}.`;
+    case "arabicParenR":
+      return `${index})`;
+    case "arabicPlain":
+      return `${index}`;
+    case "romanUcPeriod":
+      return `${toRoman(index)}.`;
+    case "romanLcPeriod":
+      return `${toRoman(index).toLowerCase()}.`;
+    case "alphaUcPeriod":
+      return `${toAlpha(index)}.`;
+    case "alphaLcPeriod":
+      return `${toAlpha(index).toLowerCase()}.`;
+    case "alphaUcParenR":
+      return `${toAlpha(index)})`;
+    case "alphaLcParenR":
+      return `${toAlpha(index).toLowerCase()})`;
+    default:
+      return `${index}.`;
+  }
+}
+function toRoman(num) {
+  const romanNumerals = [
+    [1e3, "M"],
+    [900, "CM"],
+    [500, "D"],
+    [400, "CD"],
+    [100, "C"],
+    [90, "XC"],
+    [50, "L"],
+    [40, "XL"],
+    [10, "X"],
+    [9, "IX"],
+    [5, "V"],
+    [4, "IV"],
+    [1, "I"]
+  ];
+  let result = "";
+  let remaining = num;
+  for (const [value, symbol] of romanNumerals) {
+    while (remaining >= value) {
+      result += symbol;
+      remaining -= value;
+    }
+  }
+  return result;
+}
+function toAlpha(num) {
+  let result = "";
+  let remaining = num;
+  while (remaining > 0) {
+    remaining--;
+    result = String.fromCharCode(65 + remaining % 26) + result;
+    remaining = Math.floor(remaining / 26);
+  }
+  return result;
+}
+function buildBulletStyleAttrs(props, textFontSizePt, fontScale) {
+  const styles = [];
+  if (props.bulletSizePct !== null) {
+    const size = textFontSizePt * (props.bulletSizePct / 1e5);
+    styles.push(`font-size="${size}pt"`);
+  }
+  if (props.bulletFont) {
+    styles.push(`font-family="${escapeXml(props.bulletFont)}"`);
+  }
+  if (props.bulletColor) {
+    styles.push(`fill="${props.bulletColor.hex}"`);
+    if (props.bulletColor.alpha < 1) {
+      styles.push(`fill-opacity="${props.bulletColor.alpha}"`);
+    }
+  }
+  void fontScale;
+  return styles.join(" ");
+}
+function getAlignmentInfo(alignment, marginLeft, textWidth, width, marginRight) {
+  switch (alignment) {
+    case "ctr":
+      return { xPos: marginLeft + textWidth / 2, anchorValue: "middle" };
+    case "r":
+      return { xPos: width - marginRight, anchorValue: "end" };
+    default:
+      return { xPos: marginLeft, anchorValue: "start" };
+  }
+}
+function getLineSpacing(para, lnSpcReduction = 0) {
+  let spacing;
+  if (para.properties.lineSpacing !== null) {
+    const factor = para.properties.lineSpacing / 1e5;
+    spacing = Math.max(0.5, factor);
+  } else {
+    spacing = DEFAULT_LINE_SPACING;
+  }
+  return spacing * (1 - lnSpcReduction);
+}
+function computeDy(isFirstLine, fontSizePt, lineSpacingFactor, para, isFirstLineOfParagraph) {
+  if (isFirstLine) return "0";
+  const lineHeight = fontSizePt * PX_PER_PT2 * lineSpacingFactor;
+  let dy = lineHeight;
+  if (isFirstLineOfParagraph && para.properties.spaceBefore > 0) {
+    dy += para.properties.spaceBefore / 100 * PX_PER_PT2;
+  }
+  return dy.toFixed(2);
+}
+function getLineFontSize(segments, defaultFontSize) {
+  for (const seg of segments) {
+    if (seg.properties.fontSize) return seg.properties.fontSize;
+  }
+  return defaultFontSize;
+}
+function computeLineNaturalHeight(segments, defaultFontSize, fontScale) {
+  let maxHeight = 0;
+  for (const seg of segments) {
+    const fontSize = (seg.properties.fontSize ?? defaultFontSize) * fontScale;
+    const ratio = getLineHeightRatio(seg.properties.fontFamily, seg.properties.fontFamilyEa);
+    maxHeight = Math.max(maxHeight, fontSize * ratio);
+  }
+  return maxHeight > 0 ? maxHeight : defaultFontSize * fontScale * 1.2;
+}
+function isCjkCodePoint2(codePoint) {
+  return codePoint >= 12288 && codePoint <= 40959 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 131072 && codePoint <= 173791;
+}
+function splitByScript(text) {
+  const segments = [];
+  let current = "";
+  let currentIsEa = null;
+  for (const char of text) {
+    const cp = char.codePointAt(0);
+    const isEa = isCjkCodePoint2(cp);
+    if (currentIsEa !== null && isEa !== currentIsEa) {
+      segments.push({ text: current, isEa: currentIsEa });
+      current = "";
+    }
+    currentIsEa = isEa;
+    current += char;
+  }
+  if (current && currentIsEa !== null) {
+    segments.push({ text: current, isEa: currentIsEa });
+  }
+  return segments;
+}
+function needsScriptSplit(props) {
+  return props.fontFamily !== null && props.fontFamilyEa !== null && props.fontFamily !== props.fontFamilyEa;
+}
+function getGenericFamily(fontFamily) {
+  const lower = fontFamily.toLowerCase();
+  if (lower.includes("mincho") || lower.includes("\u660E\u671D") || lower === "times new roman" || lower === "georgia" || lower === "cambria" || lower.includes("serif") && !lower.includes("sans")) {
+    return "serif";
+  }
+  return "sans-serif";
+}
+function escapeFontName(name) {
+  return name.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildFontFamilyValue(fonts) {
+  const uniqueFonts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const font of fonts) {
+    if (font && !seen.has(font)) {
+      seen.add(font);
+      uniqueFonts.push(font);
+      const fallback = getMetricsFallbackFont(font);
+      if (fallback && !seen.has(fallback)) {
+        seen.add(fallback);
+        uniqueFonts.push(fallback);
+      }
+    }
+  }
+  if (uniqueFonts.length === 0) return null;
+  const genericFamily = getGenericFamily(uniqueFonts[0]);
+  const parts = uniqueFonts.map((f) => {
+    const escaped = escapeFontName(f);
+    return f.includes(" ") ? `'${escaped}'` : escaped;
+  });
+  parts.push(genericFamily);
+  return parts.join(", ");
+}
+function buildStyleAttrs(props, fontScale = 1, fontFamilies) {
+  const styles = [];
+  if (props.fontSize) {
+    const scaledSize = props.fontSize * fontScale;
+    styles.push(`font-size="${scaledSize}pt"`);
+  }
+  const fonts = fontFamilies ?? [props.fontFamily, props.fontFamilyEa];
+  const fontFamilyValue = buildFontFamilyValue(fonts);
+  if (fontFamilyValue) {
+    styles.push(`font-family="${fontFamilyValue}"`);
+  }
+  if (props.bold) {
+    styles.push(`font-weight="bold"`);
+  }
+  if (props.italic) {
+    styles.push(`font-style="italic"`);
+  }
+  if (props.color) {
+    styles.push(`fill="${props.color.hex}"`);
+    if (props.color.alpha < 1) {
+      styles.push(`fill-opacity="${props.color.alpha}"`);
+    }
+  }
+  const decorations = [];
+  if (props.underline) decorations.push("underline");
+  if (props.strikethrough) decorations.push("line-through");
+  if (decorations.length > 0) {
+    styles.push(`text-decoration="${decorations.join(" ")}"`);
+  }
+  if (props.baseline > 0) {
+    styles.push(`baseline-shift="super"`);
+  } else if (props.baseline < 0) {
+    styles.push(`baseline-shift="sub"`);
+  }
+  return styles.join(" ");
+}
+function renderSegment(text, props, fontScale, prefix) {
+  if (!needsScriptSplit(props)) {
+    const styles = buildStyleAttrs(props, fontScale);
+    return `<tspan ${prefix}${styles}>${escapeXml(text)}</tspan>`;
+  }
+  const parts = splitByScript(text);
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const fonts = part.isEa ? [props.fontFamilyEa, props.fontFamily] : [props.fontFamily, props.fontFamilyEa];
+    const styles = buildStyleAttrs(props, fontScale, fonts);
+    if (i === 0) {
+      result.push(`<tspan ${prefix}${styles}>${escapeXml(part.text)}</tspan>`);
+    } else {
+      result.push(`<tspan ${styles}>${escapeXml(part.text)}</tspan>`);
+    }
+  }
+  return result.join("");
+}
+function getDefaultFontSize(paragraphs) {
+  for (const p of paragraphs) {
+    for (const r of p.runs) {
+      if (r.properties.fontSize) return r.properties.fontSize;
+    }
+  }
+  return DEFAULT_FONT_SIZE_PT;
+}
+function getDefaultLineHeightRatio(paragraphs) {
+  for (const p of paragraphs) {
+    for (const r of p.runs) {
+      if (r.properties.fontFamily || r.properties.fontFamilyEa) {
+        return getLineHeightRatio(r.properties.fontFamily, r.properties.fontFamilyEa);
+      }
+    }
+  }
+  return 1.2;
+}
+function estimateTextHeight(paragraphs, defaultFontSize, shouldWrap, textWidth, lnSpcReduction = 0, fontScale = 1) {
+  let totalHeight = 0;
+  const defaultRatio = getDefaultLineHeightRatio(paragraphs);
+  for (let pIdx = 0; pIdx < paragraphs.length; pIdx++) {
+    const para = paragraphs[pIdx];
+    const lineSpacing = getLineSpacing(para, lnSpcReduction);
+    const naturalHeight = computeLineNaturalHeight(para.runs, defaultFontSize, fontScale);
+    const lineHeight = (naturalHeight > 0 ? naturalHeight : defaultFontSize * fontScale * defaultRatio) * PX_PER_PT2 * lineSpacing;
+    let lineCount;
+    if (shouldWrap && para.runs.length > 0 && para.runs.some((r) => r.text.length > 0)) {
+      const wrappedLines = wrapParagraph(para, textWidth, defaultFontSize, fontScale);
+      lineCount = wrappedLines.length;
+    } else {
+      lineCount = para.runs.some((r) => r.text.length > 0) ? 1 : 1;
+    }
+    totalHeight += lineCount * lineHeight;
+    if (pIdx > 0 && para.properties.spaceBefore > 0) {
+      totalHeight += para.properties.spaceBefore / 100 * PX_PER_PT2;
+    }
+  }
+  return totalHeight;
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/renderer/effect-renderer.ts
+function renderEffects(effects) {
+  if (!effects) {
+    return { filterAttr: "", filterDefs: "" };
+  }
+  const primitives = [];
+  let lastResult = "SourceGraphic";
+  if (effects.softEdge) {
+    const r = emuToPixels(effects.softEdge.radius);
+    primitives.push(
+      `<feGaussianBlur in="SourceAlpha" stdDeviation="${r}" result="softEdgeMask"/>`,
+      `<feComposite in="SourceGraphic" in2="softEdgeMask" operator="in" result="softEdgeResult"/>`
+    );
+    lastResult = "softEdgeResult";
+  }
+  if (effects.glow) {
+    const r = emuToPixels(effects.glow.radius);
+    const { hex, alpha } = effects.glow.color;
+    if (lastResult !== "SourceGraphic") {
+      primitives.push(
+        `<feColorMatrix in="${lastResult}" type="matrix" values="0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 1 0" result="glowAlpha"/>`
+      );
+    }
+    const blurIn = lastResult === "SourceGraphic" ? "SourceAlpha" : "glowAlpha";
+    const mergeIn = lastResult;
+    primitives.push(
+      `<feGaussianBlur in="${blurIn}" stdDeviation="${r}" result="glowBlur"/>`,
+      `<feFlood flood-color="${hex}" flood-opacity="${alpha}" result="glowColor"/>`,
+      `<feComposite in="glowColor" in2="glowBlur" operator="in" result="glowFinal"/>`,
+      `<feMerge result="glowMerge">`,
+      `<feMergeNode in="glowFinal"/>`,
+      `<feMergeNode in="${mergeIn}"/>`,
+      `</feMerge>`
+    );
+    lastResult = "glowMerge";
+  }
+  if (effects.outerShadow) {
+    const stdDev = emuToPixels(effects.outerShadow.blurRadius) / 2;
+    const dist = emuToPixels(effects.outerShadow.distance);
+    const dirRad = effects.outerShadow.direction * Math.PI / 180;
+    const dx = round(dist * Math.cos(dirRad));
+    const dy = round(dist * Math.sin(dirRad));
+    const { hex, alpha } = effects.outerShadow.color;
+    const mergeIn = lastResult;
+    primitives.push(
+      `<feGaussianBlur in="SourceAlpha" stdDeviation="${stdDev}" result="shadowBlur"/>`,
+      `<feOffset in="shadowBlur" dx="${dx}" dy="${dy}" result="shadowOffset"/>`,
+      `<feFlood flood-color="${hex}" flood-opacity="${alpha}" result="shadowColor"/>`,
+      `<feComposite in="shadowColor" in2="shadowOffset" operator="in" result="shadowFinal"/>`,
+      `<feMerge result="outerShadowMerge">`,
+      `<feMergeNode in="shadowFinal"/>`,
+      `<feMergeNode in="${mergeIn}"/>`,
+      `</feMerge>`
+    );
+    lastResult = "outerShadowMerge";
+  }
+  if (effects.innerShadow) {
+    const stdDev = emuToPixels(effects.innerShadow.blurRadius) / 2;
+    const dist = emuToPixels(effects.innerShadow.distance);
+    const dirRad = effects.innerShadow.direction * Math.PI / 180;
+    const dx = round(dist * Math.cos(dirRad));
+    const dy = round(dist * Math.sin(dirRad));
+    const { hex, alpha } = effects.innerShadow.color;
+    const sourceIn = lastResult;
+    primitives.push(
+      `<feComponentTransfer in="SourceAlpha" result="innerShdwInverse">`,
+      `<feFuncA type="table" tableValues="1 0"/>`,
+      `</feComponentTransfer>`,
+      `<feGaussianBlur in="innerShdwInverse" stdDeviation="${stdDev}" result="innerShdwBlur"/>`,
+      `<feOffset in="innerShdwBlur" dx="${dx}" dy="${dy}" result="innerShdwOffset"/>`,
+      `<feFlood flood-color="${hex}" flood-opacity="${alpha}" result="innerShdwFill"/>`,
+      `<feComposite in="innerShdwFill" in2="innerShdwOffset" operator="in" result="innerShdwColored"/>`,
+      `<feComposite in="innerShdwColored" in2="SourceAlpha" operator="in" result="innerShdwClipped"/>`,
+      `<feComposite in="innerShdwClipped" in2="${sourceIn}" operator="over"/>`
+    );
+    lastResult = "";
+  }
+  if (primitives.length === 0) {
+    return { filterAttr: "", filterDefs: "" };
+  }
+  const id = `effect-${crypto.randomUUID()}`;
+  const filterDefs = [
+    `<filter id="${id}" x="-50%" y="-50%" width="200%" height="200%" color-interpolation-filters="sRGB">`,
+    ...primitives,
+    `</filter>`
+  ].join("");
+  return {
+    filterAttr: `filter="url(#${id})"`,
+    filterDefs
+  };
+}
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+
+// src/renderer/transform.ts
+function buildTransformAttr(t) {
+  const x = emuToPixels(t.offsetX);
+  const y = emuToPixels(t.offsetY);
+  const w = emuToPixels(t.extentWidth);
+  const h = emuToPixels(t.extentHeight);
+  const parts = [];
+  parts.push(`translate(${x}, ${y})`);
+  if (t.rotation !== 0) {
+    parts.push(`rotate(${t.rotation}, ${w / 2}, ${h / 2})`);
+  }
+  if (t.flipH || t.flipV) {
+    const sx = t.flipH ? -1 : 1;
+    const sy = t.flipV ? -1 : 1;
+    parts.push(`translate(${t.flipH ? w : 0}, ${t.flipV ? h : 0})`);
+    parts.push(`scale(${sx}, ${sy})`);
+  }
+  return parts.join(" ");
+}
+
+// src/renderer/shape-renderer.ts
+function renderShape(shape) {
+  const { transform, geometry, fill, outline, textBody, effects } = shape;
+  const w = emuToPixels(transform.extentWidth);
+  const h = emuToPixels(transform.extentHeight);
+  const transformAttr = buildTransformAttr(transform);
+  const fillResult = renderFillAttrs(fill);
+  const outlineAttr = renderOutlineAttrs(outline);
+  const effectResult = renderEffects(effects);
+  const geometrySvg = renderGeometry(geometry, w, h);
+  const parts = [];
+  if (fillResult.defs) {
+    parts.push(fillResult.defs);
+  }
+  if (effectResult.filterDefs) {
+    parts.push(effectResult.filterDefs);
+  }
+  const filterAttr = effectResult.filterAttr ? ` ${effectResult.filterAttr}` : "";
+  parts.push(`<g transform="${transformAttr}"${filterAttr}>`);
+  if (geometrySvg) {
+    const styledGeometry = geometrySvg.replace(/^<(\w+)/, `<$1 ${fillResult.attrs} ${outlineAttr}`);
+    parts.push(styledGeometry);
+  }
+  if (textBody) {
+    const textSvg = renderTextBody(textBody, transform);
+    if (textSvg) {
+      parts.push(textSvg);
+    }
+  }
+  parts.push("</g>");
+  return parts.join("");
+}
+function renderConnector(connector) {
+  const { transform, outline, effects } = connector;
+  const w = emuToPixels(transform.extentWidth);
+  const h = emuToPixels(transform.extentHeight);
+  const transformAttr = buildTransformAttr(transform);
+  const outlineAttr = renderOutlineAttrs(outline);
+  const effectResult = renderEffects(effects);
+  const parts = [];
+  if (effectResult.filterDefs) {
+    parts.push(effectResult.filterDefs);
+  }
+  const filterAttr = effectResult.filterAttr ? ` ${effectResult.filterAttr}` : "";
+  parts.push(
+    `<g transform="${transformAttr}"${filterAttr}><line x1="0" y1="0" x2="${w}" y2="${h}" ${outlineAttr} fill="none"/></g>`
+  );
+  return parts.join("");
+}
+
+// src/renderer/image-renderer.ts
+function renderImage(image) {
+  const w = emuToPixels(image.transform.extentWidth);
+  const h = emuToPixels(image.transform.extentHeight);
+  const transformAttr = buildTransformAttr(image.transform);
+  const effectResult = renderEffects(image.effects);
+  const parts = [];
+  if (effectResult.filterDefs) {
+    parts.push(effectResult.filterDefs);
+  }
+  const filterAttr = effectResult.filterAttr ? ` ${effectResult.filterAttr}` : "";
+  parts.push(
+    `<g transform="${transformAttr}"${filterAttr}><image href="data:${image.mimeType};base64,${image.imageData}" width="${w}" height="${h}" preserveAspectRatio="none"/></g>`
+  );
+  return parts.join("");
+}
+
+// src/renderer/chart-renderer.ts
+var DEFAULT_SERIES_COLORS = [
+  { hex: "#4472C4", alpha: 1 },
+  { hex: "#ED7D31", alpha: 1 },
+  { hex: "#A5A5A5", alpha: 1 },
+  { hex: "#FFC000", alpha: 1 },
+  { hex: "#5B9BD5", alpha: 1 },
+  { hex: "#70AD47", alpha: 1 }
+];
+function renderChart(element) {
+  const { transform, chart } = element;
+  const w = emuToPixels(transform.extentWidth);
+  const h = emuToPixels(transform.extentHeight);
+  const transformAttr = buildTransformAttr(transform);
+  const parts = [];
+  parts.push(`<g transform="${transformAttr}">`);
+  parts.push(
+    `<rect width="${w}" height="${h}" fill="#FFFFFF" stroke="#D9D9D9" stroke-width="0.5"/>`
+  );
+  const margin = { top: 20, right: 20, bottom: 30, left: 50 };
+  if (chart.title) {
+    parts.push(renderChartTitle(chart.title, w));
+    margin.top = 40;
+  }
+  if (chart.legend) {
+    if (chart.legend.position === "b") margin.bottom = 50;
+    else if (chart.legend.position === "t") margin.top += 20;
+  }
+  const plotX = margin.left;
+  const plotY = margin.top;
+  const plotW = Math.max(w - margin.left - margin.right, 0);
+  const plotH = Math.max(h - margin.top - margin.bottom, 0);
+  if (plotW > 0 && plotH > 0) {
+    switch (chart.chartType) {
+      case "bar":
+        parts.push(renderBarChart(chart, plotX, plotY, plotW, plotH));
+        break;
+      case "line":
+        parts.push(renderLineChart(chart, plotX, plotY, plotW, plotH));
+        break;
+      case "pie":
+        parts.push(renderPieChart(chart, plotX, plotY, plotW, plotH));
+        break;
+      case "scatter":
+        parts.push(renderScatterChart(chart, plotX, plotY, plotW, plotH));
+        break;
+    }
+  }
+  if (chart.legend && chart.series.length > 0) {
+    parts.push(renderLegend(chart, w, h, chart.legend.position));
+  }
+  parts.push("</g>");
+  return parts.join("");
+}
+function renderChartTitle(title, chartWidth) {
+  return `<text x="${round2(chartWidth / 2)}" y="20" text-anchor="middle" font-size="14" font-weight="bold" fill="#404040">${escapeXml2(title)}</text>`;
+}
+function renderBarChart(chart, x, y, w, h) {
+  const parts = [];
+  const { series, categories } = chart;
+  if (series.length === 0) return "";
+  const maxVal = getMaxValue(series);
+  if (maxVal === 0) return "";
+  const catCount = categories.length || Math.max(...series.map((s) => s.values.length));
+  if (catCount === 0) return "";
+  const isHorizontal = chart.barDirection === "bar";
+  parts.push(
+    `<line x1="${round2(x)}" y1="${round2(y + h)}" x2="${round2(x + w)}" y2="${round2(y + h)}" stroke="#D9D9D9" stroke-width="1"/>`
+  );
+  parts.push(
+    `<line x1="${round2(x)}" y1="${round2(y)}" x2="${round2(x)}" y2="${round2(y + h)}" stroke="#D9D9D9" stroke-width="1"/>`
+  );
+  if (isHorizontal) {
+    const groupHeight = h / catCount;
+    const barHeight = groupHeight * 0.7 / series.length;
+    const groupPadding = groupHeight * 0.15;
+    for (let c = 0; c < catCount; c++) {
+      const label = categories[c] ?? "";
+      const labelY = y + c * groupHeight + groupHeight / 2;
+      parts.push(
+        `<text x="${round2(x - 5)}" y="${round2(labelY + 4)}" text-anchor="end" font-size="10" fill="#595959">${escapeXml2(label)}</text>`
+      );
+    }
+    for (let s = 0; s < series.length; s++) {
+      const color = series[s].color;
+      for (let c = 0; c < series[s].values.length; c++) {
+        const val = series[s].values[c];
+        const barW = val / maxVal * w;
+        const barX = x;
+        const barY = y + c * groupHeight + groupPadding + s * barHeight;
+        parts.push(
+          `<rect x="${round2(barX)}" y="${round2(barY)}" width="${round2(barW)}" height="${round2(barHeight)}" ${fillAttr(color)}/>`
+        );
+      }
+    }
+  } else {
+    const groupWidth = w / catCount;
+    const barWidth = groupWidth * 0.7 / series.length;
+    const groupPadding = groupWidth * 0.15;
+    for (let c = 0; c < catCount; c++) {
+      const label = categories[c] ?? "";
+      const labelX = x + c * groupWidth + groupWidth / 2;
+      parts.push(
+        `<text x="${round2(labelX)}" y="${round2(y + h + 15)}" text-anchor="middle" font-size="10" fill="#595959">${escapeXml2(label)}</text>`
+      );
+    }
+    for (let s = 0; s < series.length; s++) {
+      const color = series[s].color;
+      for (let c = 0; c < series[s].values.length; c++) {
+        const val = series[s].values[c];
+        const barH = val / maxVal * h;
+        const barX = x + c * groupWidth + groupPadding + s * barWidth;
+        const barY = y + h - barH;
+        parts.push(
+          `<rect x="${round2(barX)}" y="${round2(barY)}" width="${round2(barWidth)}" height="${round2(barH)}" ${fillAttr(color)}/>`
+        );
+      }
+    }
+  }
+  return parts.join("");
+}
+function renderLineChart(chart, x, y, w, h) {
+  const parts = [];
+  const { series, categories } = chart;
+  if (series.length === 0) return "";
+  const maxVal = getMaxValue(series);
+  if (maxVal === 0) return "";
+  const catCount = categories.length || Math.max(...series.map((s) => s.values.length));
+  if (catCount === 0) return "";
+  parts.push(
+    `<line x1="${round2(x)}" y1="${round2(y + h)}" x2="${round2(x + w)}" y2="${round2(y + h)}" stroke="#D9D9D9" stroke-width="1"/>`
+  );
+  parts.push(
+    `<line x1="${round2(x)}" y1="${round2(y)}" x2="${round2(x)}" y2="${round2(y + h)}" stroke="#D9D9D9" stroke-width="1"/>`
+  );
+  for (let c = 0; c < catCount; c++) {
+    const label = categories[c] ?? "";
+    const divisor = catCount > 1 ? catCount - 1 : 1;
+    const labelX = x + c / divisor * w;
+    parts.push(
+      `<text x="${round2(labelX)}" y="${round2(y + h + 15)}" text-anchor="middle" font-size="10" fill="#595959">${escapeXml2(label)}</text>`
+    );
+  }
+  for (let s = 0; s < series.length; s++) {
+    const color = series[s].color;
+    const divisor = catCount > 1 ? catCount - 1 : 1;
+    const points = series[s].values.map((val, i) => {
+      const px = round2(x + i / divisor * w);
+      const py = round2(y + h - val / maxVal * h);
+      return `${px},${py}`;
+    });
+    parts.push(
+      `<polyline points="${points.join(" ")}" fill="none" stroke="${color.hex}" stroke-width="2"${color.alpha < 1 ? ` stroke-opacity="${color.alpha}"` : ""}/>`
+    );
+    for (const point of points) {
+      const [px, py] = point.split(",");
+      parts.push(`<circle cx="${px}" cy="${py}" r="3" ${fillAttr(color)}/>`);
+    }
+  }
+  return parts.join("");
+}
+function renderPieChart(chart, x, y, w, h) {
+  const parts = [];
+  const series = chart.series[0];
+  if (!series || series.values.length === 0) return "";
+  const total = series.values.reduce((sum, v) => sum + v, 0);
+  if (total === 0) return "";
+  const cx = x + w / 2;
+  const cy = y + h / 2;
+  const r = Math.min(w, h) / 2 * 0.85;
+  let currentAngle = -Math.PI / 2;
+  for (let i = 0; i < series.values.length; i++) {
+    const val = series.values[i];
+    const sliceAngle = val / total * 2 * Math.PI;
+    const color = getPieSliceColor(i, chart);
+    if (series.values.length === 1) {
+      parts.push(
+        `<circle cx="${round2(cx)}" cy="${round2(cy)}" r="${round2(r)}" ${fillAttr(color)}/>`
+      );
+    } else {
+      const x1 = cx + r * Math.cos(currentAngle);
+      const y1 = cy + r * Math.sin(currentAngle);
+      const x2 = cx + r * Math.cos(currentAngle + sliceAngle);
+      const y2 = cy + r * Math.sin(currentAngle + sliceAngle);
+      const largeArc = sliceAngle > Math.PI ? 1 : 0;
+      parts.push(
+        `<path d="M${round2(cx)},${round2(cy)} L${round2(x1)},${round2(y1)} A${round2(r)},${round2(r)} 0 ${largeArc},1 ${round2(x2)},${round2(y2)} Z" ${fillAttr(color)}/>`
+      );
+    }
+    currentAngle += sliceAngle;
+  }
+  return parts.join("");
+}
+function renderScatterChart(chart, x, y, w, h) {
+  const parts = [];
+  const { series } = chart;
+  if (series.length === 0) return "";
+  let maxX = 0;
+  let maxY = 0;
+  for (const s of series) {
+    const xVals = s.xValues ?? [];
+    for (const v of xVals) maxX = Math.max(maxX, v);
+    for (const v of s.values) maxY = Math.max(maxY, v);
+  }
+  if (maxX === 0) maxX = 1;
+  if (maxY === 0) maxY = 1;
+  parts.push(
+    `<line x1="${round2(x)}" y1="${round2(y + h)}" x2="${round2(x + w)}" y2="${round2(y + h)}" stroke="#D9D9D9" stroke-width="1"/>`
+  );
+  parts.push(
+    `<line x1="${round2(x)}" y1="${round2(y)}" x2="${round2(x)}" y2="${round2(y + h)}" stroke="#D9D9D9" stroke-width="1"/>`
+  );
+  for (let s = 0; s < series.length; s++) {
+    const color = series[s].color;
+    const xVals = series[s].xValues ?? [];
+    for (let i = 0; i < series[s].values.length; i++) {
+      const xVal = xVals[i] ?? i;
+      const yVal = series[s].values[i];
+      const px = x + xVal / maxX * w;
+      const py = y + h - yVal / maxY * h;
+      parts.push(`<circle cx="${round2(px)}" cy="${round2(py)}" r="4" ${fillAttr(color)}/>`);
+    }
+  }
+  return parts.join("");
+}
+function renderLegend(chart, chartW, chartH, position) {
+  const parts = [];
+  const entries = chart.chartType === "pie" ? chart.categories.map((cat, i) => ({
+    label: cat,
+    color: getPieSliceColor(i, chart)
+  })) : chart.series.map((s, i) => ({
+    label: s.name ?? `Series ${i + 1}`,
+    color: s.color
+  }));
+  if (entries.length === 0) return "";
+  const entryWidth = 80;
+  const totalWidth = entries.length * entryWidth;
+  const startX = Math.max((chartW - totalWidth) / 2, 5);
+  const legendY = position === "t" ? 25 : chartH - 15;
+  for (let i = 0; i < entries.length; i++) {
+    const ex = startX + i * entryWidth;
+    parts.push(
+      `<rect x="${round2(ex)}" y="${round2(legendY - 6)}" width="12" height="12" ${fillAttr(entries[i].color)}/>`
+    );
+    parts.push(
+      `<text x="${round2(ex + 16)}" y="${round2(legendY + 4)}" font-size="10" fill="#595959">${escapeXml2(entries[i].label)}</text>`
+    );
+  }
+  return parts.join("");
+}
+function getPieSliceColor(index, chart) {
+  const series = chart.series[0];
+  if (series) {
+    return DEFAULT_SERIES_COLORS[index % DEFAULT_SERIES_COLORS.length];
+  }
+  return DEFAULT_SERIES_COLORS[index % DEFAULT_SERIES_COLORS.length];
+}
+function getMaxValue(series) {
+  let max = 0;
+  for (const s of series) {
+    for (const v of s.values) {
+      max = Math.max(max, v);
+    }
+  }
+  return max;
+}
+function fillAttr(color) {
+  const alpha = color.alpha < 1 ? ` fill-opacity="${color.alpha}"` : "";
+  return `fill="${color.hex}"${alpha}`;
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function escapeXml2(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/renderer/table-renderer.ts
+function renderTable(element, defs) {
+  const { transform, table } = element;
+  const transformAttr = buildTransformAttr(transform);
+  const colWidths = table.columns.map((col) => emuToPixels(col.width));
+  const rowHeights = table.rows.map((row) => emuToPixels(row.height));
+  const parts = [];
+  parts.push(`<g transform="${transformAttr}">`);
+  let y = 0;
+  for (let rowIdx = 0; rowIdx < table.rows.length; rowIdx++) {
+    const row = table.rows[rowIdx];
+    const rowH = rowHeights[rowIdx];
+    let x = 0;
+    let colIdx = 0;
+    for (const cell of row.cells) {
+      if (cell.hMerge || cell.vMerge) {
+        x += colWidths[colIdx] ?? 0;
+        colIdx++;
+        continue;
+      }
+      const cellW = computeSpannedSize(colWidths, colIdx, cell.gridSpan);
+      const cellH = computeSpannedSize(rowHeights, rowIdx, cell.rowSpan);
+      const fillResult = renderFillAttrs(cell.fill);
+      if (fillResult.defs) defs.push(fillResult.defs);
+      parts.push(
+        `<rect x="${x}" y="${y}" width="${cellW}" height="${cellH}" ${fillResult.attrs}/>`
+      );
+      if (cell.borders) {
+        if (cell.borders.top) {
+          const attrs = renderOutlineAttrs(cell.borders.top);
+          parts.push(`<line x1="${x}" y1="${y}" x2="${x + cellW}" y2="${y}" ${attrs}/>`);
+        }
+        if (cell.borders.bottom) {
+          const attrs = renderOutlineAttrs(cell.borders.bottom);
+          parts.push(
+            `<line x1="${x}" y1="${y + cellH}" x2="${x + cellW}" y2="${y + cellH}" ${attrs}/>`
+          );
+        }
+        if (cell.borders.left) {
+          const attrs = renderOutlineAttrs(cell.borders.left);
+          parts.push(`<line x1="${x}" y1="${y}" x2="${x}" y2="${y + cellH}" ${attrs}/>`);
+        }
+        if (cell.borders.right) {
+          const attrs = renderOutlineAttrs(cell.borders.right);
+          parts.push(
+            `<line x1="${x + cellW}" y1="${y}" x2="${x + cellW}" y2="${y + cellH}" ${attrs}/>`
+          );
+        }
+      }
+      if (cell.textBody) {
+        const cellTransform = {
+          offsetX: 0,
+          offsetY: 0,
+          extentWidth: pixelsToEmu(cellW),
+          extentHeight: pixelsToEmu(cellH),
+          rotation: 0,
+          flipH: false,
+          flipV: false
+        };
+        const textSvg = renderTextBody(cell.textBody, cellTransform);
+        if (textSvg) {
+          parts.push(`<g transform="translate(${x}, ${y})">${textSvg}</g>`);
+        }
+      }
+      x += colWidths[colIdx] ?? 0;
+      colIdx++;
+    }
+    y += rowH;
+  }
+  parts.push("</g>");
+  return parts.join("");
+}
+function computeSpannedSize(sizes, startIdx, span) {
+  let total = 0;
+  for (let i = startIdx; i < startIdx + span && i < sizes.length; i++) {
+    total += sizes[i];
+  }
+  return total;
+}
+function pixelsToEmu(px) {
+  return px / 96 * 914400;
+}
+
+// src/renderer/svg-renderer.ts
+function renderSlideToSvg(slide, slideSize) {
+  const width = emuToPixels(slideSize.width);
+  const height = emuToPixels(slideSize.height);
+  const parts = [];
+  const defs = [];
+  parts.push(
+    `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}">`
+  );
+  if (slide.background?.fill?.type === "image") {
+    const bg = slide.background.fill;
+    parts.push(
+      `<image href="data:${bg.mimeType};base64,${bg.imageData}" width="${width}" height="${height}" preserveAspectRatio="none"/>`
+    );
+  } else if (slide.background?.fill) {
+    const fillResult = renderFillAttrs(slide.background.fill);
+    if (fillResult.defs) defs.push(fillResult.defs);
+    parts.push(`<rect width="${width}" height="${height}" ${fillResult.attrs}/>`);
+  } else {
+    parts.push(`<rect width="${width}" height="${height}" fill="#FFFFFF"/>`);
+  }
+  for (const element of slide.elements) {
+    const rendered = renderElement(element, defs);
+    if (rendered) parts.push(rendered);
+  }
+  if (defs.length > 0) {
+    parts.splice(1, 0, `<defs>${defs.join("")}</defs>`);
+  }
+  parts.push("</svg>");
+  return parts.join("");
+}
+function renderElement(element, defs) {
+  switch (element.type) {
+    case "shape": {
+      const result = renderShape(element);
+      extractDefs(result, defs);
+      return removeDefs(result);
+    }
+    case "image": {
+      const imgResult = renderImage(element);
+      extractDefs(imgResult, defs);
+      return removeDefs(imgResult);
+    }
+    case "connector": {
+      const cxnResult = renderConnector(element);
+      extractDefs(cxnResult, defs);
+      return removeDefs(cxnResult);
+    }
+    case "group":
+      return renderGroup(element, defs);
+    case "chart":
+      return renderChart(element);
+    case "table":
+      return renderTable(element, defs);
+    default:
+      return null;
+  }
+}
+function renderGroup(group, defs) {
+  const x = emuToPixels(group.transform.offsetX);
+  const y = emuToPixels(group.transform.offsetY);
+  const w = emuToPixels(group.transform.extentWidth);
+  const h = emuToPixels(group.transform.extentHeight);
+  const chW = emuToPixels(group.childTransform.extentWidth);
+  const chH = emuToPixels(group.childTransform.extentHeight);
+  const chX = emuToPixels(group.childTransform.offsetX);
+  const chY = emuToPixels(group.childTransform.offsetY);
+  const scaleX = chW !== 0 ? w / chW : 1;
+  const scaleY = chH !== 0 ? h / chH : 1;
+  const parts = [];
+  parts.push(
+    `<g transform="translate(${x}, ${y}) scale(${scaleX}, ${scaleY}) translate(${-chX}, ${-chY})">`
+  );
+  for (const child of group.children) {
+    const rendered = renderElement(child, defs);
+    if (rendered) parts.push(rendered);
+  }
+  parts.push("</g>");
+  return parts.join("");
+}
+function extractDefs(svgFragment, defs) {
+  const gradientMatch = svgFragment.match(/<linearGradient[^]*?<\/linearGradient>/g);
+  if (gradientMatch) {
+    defs.push(...gradientMatch);
+  }
+  const filterMatch = svgFragment.match(/<filter[^]*?<\/filter>/g);
+  if (filterMatch) {
+    defs.push(...filterMatch);
+  }
+}
+function removeDefs(svgFragment) {
+  return svgFragment.replace(/<linearGradient[^]*?<\/linearGradient>/g, "").replace(/<filter[^]*?<\/filter>/g, "");
+}
+
+// src/png/png-converter.ts
+import sharp from "sharp";
+async function svgToPng(svgString, options) {
+  const svgBuffer = Buffer.from(svgString);
+  let pipeline = sharp(svgBuffer);
+  if (options?.width || options?.height) {
+    pipeline = pipeline.resize({
+      width: options.width,
+      height: options.height,
+      fit: "contain",
+      background: { r: 255, g: 255, b: 255, alpha: 1 }
+    });
+  }
+  const result = await pipeline.png().toBuffer({ resolveWithObject: true });
+  return {
+    png: result.data,
+    width: result.info.width,
+    height: result.info.height
+  };
+}
+
+// src/converter.ts
+async function convertPptxToSvg(input, options) {
+  const archive = await readPptx(input);
+  const presentationXml = archive.files.get("ppt/presentation.xml");
+  if (!presentationXml) throw new Error("Invalid PPTX: missing ppt/presentation.xml");
+  const presInfo = parsePresentation(presentationXml);
+  const presRelsXml = archive.files.get("ppt/_rels/presentation.xml.rels");
+  const presRels = presRelsXml ? parseRelationships(presRelsXml) : /* @__PURE__ */ new Map();
+  let theme = {
+    colorScheme: defaultColorScheme2(),
+    fontScheme: {
+      majorFont: "Calibri",
+      minorFont: "Calibri",
+      majorFontEa: null,
+      minorFontEa: null
+    }
+  };
+  for (const [, rel] of presRels) {
+    if (rel.type.includes("theme")) {
+      const themePath = resolveRelationshipTarget("ppt/presentation.xml", rel.target);
+      const themeXml = archive.files.get(themePath);
+      if (themeXml) {
+        theme = parseTheme(themeXml);
+      }
+      break;
+    }
+  }
+  let colorMap = defaultColorMap();
+  let masterPath = null;
+  for (const [, rel] of presRels) {
+    if (rel.type.includes("slideMaster")) {
+      masterPath = resolveRelationshipTarget("ppt/presentation.xml", rel.target);
+      const masterXml2 = archive.files.get(masterPath);
+      if (masterXml2) {
+        colorMap = parseSlideMasterColorMap(masterXml2);
+      }
+      break;
+    }
+  }
+  const colorResolver = new ColorResolver(theme.colorScheme, colorMap);
+  const masterXml = masterPath ? archive.files.get(masterPath) : void 0;
+  let masterFillContext;
+  if (masterPath) {
+    const masterRelsPath = buildRelsPath(masterPath);
+    const masterRelsXml = archive.files.get(masterRelsPath);
+    const masterRels = masterRelsXml ? parseRelationships(masterRelsXml) : /* @__PURE__ */ new Map();
+    masterFillContext = { rels: masterRels, archive, basePath: masterPath };
+  }
+  const masterBackground = masterXml ? parseSlideMasterBackground(masterXml, colorResolver, masterFillContext) : null;
+  const masterElements = masterPath && masterXml ? parseSlideMasterElements(masterXml, masterPath, archive, colorResolver) : [];
+  const slidePaths = [];
+  for (let i = 0; i < presInfo.slideRIds.length; i++) {
+    const rId = presInfo.slideRIds[i];
+    const rel = presRels.get(rId);
+    if (rel) {
+      const path = resolveRelationshipTarget("ppt/presentation.xml", rel.target);
+      slidePaths.push({ slideNumber: i + 1, path });
+    }
+  }
+  const targetSlides = options?.slides ? slidePaths.filter((s) => options.slides.includes(s.slideNumber)) : slidePaths;
+  const results = [];
+  for (const { slideNumber, path } of targetSlides) {
+    const slideXml = archive.files.get(path);
+    if (!slideXml) continue;
+    const slide = parseSlide(slideXml, path, slideNumber, archive, colorResolver);
+    let layoutElements = [];
+    const slideRelsPath = buildRelsPath(path);
+    const slideRelsXml = archive.files.get(slideRelsPath);
+    if (slideRelsXml) {
+      const slideRels = parseRelationships(slideRelsXml);
+      for (const [, rel] of slideRels) {
+        if (rel.type.includes("slideLayout")) {
+          const layoutPath = resolveRelationshipTarget(path, rel.target);
+          const layoutXml = archive.files.get(layoutPath);
+          if (layoutXml) {
+            if (!slide.background) {
+              const layoutRelsPath = buildRelsPath(layoutPath);
+              const layoutRelsXml = archive.files.get(layoutRelsPath);
+              const layoutRels = layoutRelsXml ? parseRelationships(layoutRelsXml) : /* @__PURE__ */ new Map();
+              const layoutFillContext = {
+                rels: layoutRels,
+                archive,
+                basePath: layoutPath
+              };
+              slide.background = parseSlideLayoutBackground(
+                layoutXml,
+                colorResolver,
+                layoutFillContext
+              );
+            }
+            layoutElements = parseSlideLayoutElements(
+              layoutXml,
+              layoutPath,
+              archive,
+              colorResolver
+            );
+          }
+          break;
+        }
+      }
+    }
+    if (!slide.background) {
+      slide.background = masterBackground;
+    }
+    slide.elements = mergeElements(masterElements, layoutElements, slide.elements);
+    const svg = renderSlideToSvg(slide, presInfo.slideSize);
+    results.push({ slideNumber, svg });
+  }
+  return results;
+}
+async function convertPptxToPng(input, options) {
+  const svgResults = await convertPptxToSvg(input, options);
+  const width = options?.width ?? DEFAULT_OUTPUT_WIDTH;
+  const height = options?.height;
+  const results = [];
+  for (const { slideNumber, svg } of svgResults) {
+    const pngResult = await svgToPng(svg, { width, height });
+    results.push({
+      slideNumber,
+      png: pngResult.png,
+      width: pngResult.width,
+      height: pngResult.height
+    });
+  }
+  return results;
+}
+function collectPlaceholderTypes(elements) {
+  const types = /* @__PURE__ */ new Set();
+  for (const el of elements) {
+    if (el.type === "shape" && el.placeholderType) {
+      types.add(el.placeholderType);
+    }
+  }
+  return types;
+}
+function filterByPlaceholder(elements, excludeTypes) {
+  return elements.filter((el) => {
+    if (el.type !== "shape") return true;
+    if (!el.placeholderType) return true;
+    return !excludeTypes.has(el.placeholderType);
+  });
+}
+function mergeElements(masterElements, layoutElements, slideElements) {
+  const slidePh = collectPlaceholderTypes(slideElements);
+  const layoutPh = collectPlaceholderTypes(layoutElements);
+  const allOverrides = /* @__PURE__ */ new Set([...slidePh, ...layoutPh]);
+  const filteredMaster = filterByPlaceholder(masterElements, allOverrides);
+  const filteredLayout = filterByPlaceholder(layoutElements, slidePh);
+  return [...filteredMaster, ...filteredLayout, ...slideElements];
+}
+function defaultColorScheme2() {
+  return {
+    dk1: "#000000",
+    lt1: "#FFFFFF",
+    dk2: "#44546A",
+    lt2: "#E7E6E6",
+    accent1: "#4472C4",
+    accent2: "#ED7D31",
+    accent3: "#A5A5A5",
+    accent4: "#FFC000",
+    accent5: "#5B9BD5",
+    accent6: "#70AD47",
+    hlink: "#0563C1",
+    folHlink: "#954F72"
+  };
+}
+function defaultColorMap() {
+  return {
+    bg1: "lt1",
+    tx1: "dk1",
+    bg2: "lt2",
+    tx2: "dk2",
+    accent1: "accent1",
+    accent2: "accent2",
+    accent3: "accent3",
+    accent4: "accent4",
+    accent5: "accent5",
+    accent6: "accent6",
+    hlink: "hlink",
+    folHlink: "folHlink"
+  };
+}
+export {
+  convertPptxToPng,
+  convertPptxToSvg
+};