pptx-glimpse 0.1.0 → 0.1.2

package/dist/index.js

@@ -29,27 +29,52 @@ async function readPptx(input) {
 import { XMLParser } from "fast-xml-parser";
 var ARRAY_TAGS = /* @__PURE__ */ new Set([
   "sp",
+  // 図形 (Shape)
   "pic",
+  // 画像 (Picture)
   "cxnSp",
+  // コネクタ (Connector)
   "grpSp",
+  // グループ (Group Shape)
   "graphicFrame",
+  // テーブル・チャート等のフレーム
   "p",
+  // テキスト段落 (Paragraph)
   "r",
+  // テキストラン (Run)
   "br",
+  // 改行 (Break)
+  "fld",
+  // フィールドコード (Field)
   "Relationship",
+  // リレーションシップ
   "sldId",
+  // スライド ID
   "gs",
+  // グラデーションストップ (Gradient Stop)
   "gridCol",
+  // テーブル列定義
   "tr",
+  // テーブル行 (Table Row)
   "tc",
+  // テーブルセル (Table Cell)
   "ser",
-  "pt"
+  // チャートデータ系列 (Series)
+  "pt",
+  // チャートデータポイント (Point)
+  "gd",
+  // ガイド定義 (Guide Definition)
+  "ds",
+  // カスタムダッシュセグメント (Custom Dash Segment)
+  "AlternateContent"
+  // mc:AlternateContent (SmartArt 等)
 ]);
 function createXmlParser() {
   return new XMLParser({
     ignoreAttributes: false,
     attributeNamePrefix: "@_",
     removeNSPrefix: true,
+    htmlEntities: true,
     isArray: (_name, jpath) => {
       const tag = jpath.split(".").pop() ?? "";
       return ARRAY_TAGS.has(tag);
@@ -60,16 +85,179 @@ function parseXml(xml) {
   const parser = createXmlParser();
   return parser.parse(xml);
 }
+function parseXmlOrdered(xml) {
+  const parser = new XMLParser({
+    preserveOrder: true,
+    removeNSPrefix: true,
+    ignoreAttributes: true
+  });
+  return parser.parse(xml);
+}
+
+// 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/text-style-parser.ts
+function parseDefaultRunProperties(defRPr, colorResolver) {
+  if (!defRPr) return void 0;
+  const result = {};
+  if (defRPr["@_sz"] !== void 0) {
+    result.fontSize = hundredthPointToPoint(Number(defRPr["@_sz"]));
+  }
+  const latin = defRPr.latin;
+  if (latin?.["@_typeface"] !== void 0) {
+    result.fontFamily = latin["@_typeface"];
+  }
+  const ea = defRPr.ea;
+  if (ea?.["@_typeface"] !== void 0) {
+    result.fontFamilyEa = ea["@_typeface"];
+  }
+  if (defRPr["@_b"] !== void 0) {
+    result.bold = defRPr["@_b"] === "1" || defRPr["@_b"] === "true";
+  }
+  if (defRPr["@_i"] !== void 0) {
+    result.italic = defRPr["@_i"] === "1" || defRPr["@_i"] === "true";
+  }
+  if (defRPr["@_u"] !== void 0) {
+    result.underline = defRPr["@_u"] !== "none";
+  }
+  if (defRPr["@_strike"] !== void 0) {
+    result.strikethrough = defRPr["@_strike"] !== "noStrike";
+  }
+  if (colorResolver) {
+    const solidFill = defRPr.solidFill;
+    if (solidFill) {
+      const color = colorResolver.resolve(solidFill);
+      if (color) {
+        result.color = color;
+      }
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseParagraphLevelProperties(node, colorResolver) {
+  if (!node) return void 0;
+  const result = {};
+  if (node["@_algn"] !== void 0) {
+    result.alignment = node["@_algn"];
+  }
+  if (node["@_marL"] !== void 0) {
+    result.marginLeft = Number(node["@_marL"]);
+  }
+  if (node["@_indent"] !== void 0) {
+    result.indent = Number(node["@_indent"]);
+  }
+  const defRPr = parseDefaultRunProperties(node.defRPr, colorResolver);
+  if (defRPr) {
+    result.defaultRunProperties = defRPr;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseListStyle(node, colorResolver) {
+  if (!node) return void 0;
+  const defaultParagraph = parseParagraphLevelProperties(node.defPPr, colorResolver);
+  const levels = [];
+  for (let i = 1; i <= 9; i++) {
+    levels.push(parseParagraphLevelProperties(node[`lvl${i}pPr`], colorResolver));
+  }
+  if (!defaultParagraph && levels.every((l) => l === void 0)) {
+    return void 0;
+  }
+  return { defaultParagraph, levels };
+}
+function resolveThemeFont(typeface, fontScheme) {
+  if (!typeface || !fontScheme) return typeface;
+  switch (typeface) {
+    case "+mj-lt":
+      return fontScheme.majorFont;
+    case "+mn-lt":
+      return fontScheme.minorFont;
+    case "+mj-ea":
+      return fontScheme.majorFontEa;
+    case "+mn-ea":
+      return fontScheme.minorFontEa;
+    default:
+      return typeface;
+  }
+}
+
+// src/warning-logger.ts
+var PREFIX = "[pptx-glimpse]";
+var currentLevel = "off";
+var entries = [];
+var featureCounts = /* @__PURE__ */ new Map();
+function initWarningLogger(level) {
+  currentLevel = level;
+  entries = [];
+  featureCounts.clear();
+}
+function warn(feature, message, context) {
+  if (currentLevel === "off") return;
+  entries.push({ feature, message, ...context !== void 0 && { context } });
+  const existing = featureCounts.get(feature);
+  if (existing) {
+    existing.count++;
+  } else {
+    featureCounts.set(feature, { message, count: 1 });
+  }
+  if (currentLevel === "debug") {
+    const ctx = context ? ` (${context})` : "";
+    console.warn(`${PREFIX} SKIP: ${feature} - ${message}${ctx}`);
+  }
+}
+function debug(feature, message, context) {
+  if (currentLevel !== "debug") return;
+  entries.push({ feature, message, ...context !== void 0 && { context } });
+  const existing = featureCounts.get(feature);
+  if (existing) {
+    existing.count++;
+  } else {
+    featureCounts.set(feature, { message, count: 1 });
+  }
+  const ctx = context ? ` (${context})` : "";
+  console.warn(`${PREFIX} DEBUG: ${feature} - ${message}${ctx}`);
+}
+function getWarningSummary() {
+  const features = [];
+  for (const [feature, { message, count }] of featureCounts) {
+    features.push({ feature, message, count });
+  }
+  return { totalCount: entries.length, features };
+}
+function flushWarnings() {
+  const summary = getWarningSummary();
+  if (currentLevel !== "off" && summary.features.length > 0) {
+    console.warn(`${PREFIX} Summary: ${summary.features.length} unsupported feature(s) detected`);
+    for (const { feature, count } of summary.features) {
+      console.warn(`  - ${feature}: ${count} occurrence(s)`);
+    }
+  }
+  entries = [];
+  featureCounts.clear();
+  return summary;
+}
+function getWarningEntries() {
+  return entries;
+}
 
 // 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`);
+    debug("presentation.missing", `missing root element "presentation" in XML`);
     return {
       slideSize: { width: DEFAULT_SLIDE_WIDTH, height: DEFAULT_SLIDE_HEIGHT },
       slideRIds: []
@@ -78,8 +266,9 @@ function parsePresentation(xml) {
   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`
+    debug(
+      "presentation.sldSz",
+      `sldSz missing, using default ${DEFAULT_SLIDE_WIDTH}x${DEFAULT_SLIDE_HEIGHT} EMU`
     );
     slideSize = { width: DEFAULT_SLIDE_WIDTH, height: DEFAULT_SLIDE_HEIGHT };
   } else {
@@ -88,25 +277,24 @@ function parsePresentation(xml) {
       height: Number(sldSz["@_cy"])
     };
   }
-  const sldIdLst = pres.sldIdLst?.sldId ?? [];
-  const slideRIds = sldIdLst.map((s) => s["@_r:id"] ?? s["@_id"]).filter((id) => {
+  const sldIdLst = pres.sldIdLst;
+  const sldIdArr = sldIdLst?.sldId ?? [];
+  const slideRIds = sldIdArr.map((s) => s["@_r:id"] ?? s["@_id"]).filter((id) => {
     if (id === void 0) {
-      console.warn(
-        `${WARN_PREFIX} Presentation: undefined slide relationship ID found, skipping`
-      );
+      debug("presentation.slideRId", "undefined slide relationship ID found, skipping");
       return false;
     }
     return true;
   });
-  return { slideSize, slideRIds };
+  const defaultTextStyle = parseListStyle(pres.defaultTextStyle);
+  return { slideSize, slideRIds, defaultTextStyle };
 }
 
 // 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`);
+    debug("theme.missing", `missing root element "theme" in XML`);
     return {
       colorScheme: defaultColorScheme(),
       fontScheme: {
@@ -119,7 +307,7 @@ function parseTheme(xml) {
   }
   const themeElements = parsed.theme.themeElements;
   if (!themeElements) {
-    console.warn(`${WARN_PREFIX2} Theme: themeElements not found, using defaults`);
+    debug("theme.themeElements", "themeElements not found, using defaults");
     return {
       colorScheme: defaultColorScheme(),
       fontScheme: {
@@ -131,10 +319,10 @@ function parseTheme(xml) {
     };
   }
   if (!themeElements.clrScheme) {
-    console.warn(`${WARN_PREFIX2} Theme: colorScheme not found, using defaults`);
+    debug("theme.colorScheme", "colorScheme not found, using defaults");
   }
   if (!themeElements.fontScheme) {
-    console.warn(`${WARN_PREFIX2} Theme: fontScheme not found, using defaults`);
+    debug("theme.fontScheme", "fontScheme not found, using defaults");
   }
   const colorScheme = parseColorScheme(themeElements.clrScheme);
   const fontScheme = parseFontScheme(themeElements.fontScheme);
@@ -159,21 +347,25 @@ function parseColorScheme(clrScheme) {
 }
 function extractColor(colorNode) {
   if (!colorNode) return "#000000";
-  if (colorNode.srgbClr) {
-    return `#${colorNode.srgbClr["@_val"]}`;
+  const srgbClr = colorNode.srgbClr;
+  if (srgbClr) {
+    return `#${srgbClr["@_val"]}`;
   }
-  if (colorNode.sysClr) {
-    return `#${colorNode.sysClr["@_lastClr"] ?? "000000"}`;
+  const sysClr = colorNode.sysClr;
+  if (sysClr) {
+    return `#${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;
+  const majorFontNode = fontScheme.majorFont;
+  const minorFontNode = fontScheme.minorFont;
+  const majorFont = majorFontNode?.latin?.["@_typeface"] ?? "Calibri";
+  const minorFont = minorFontNode?.latin?.["@_typeface"] ?? "Calibri";
+  const majorFontEa = majorFontNode?.ea?.["@_typeface"] ?? null;
+  const minorFontEa = minorFontNode?.ea?.["@_typeface"] ?? null;
   return { majorFont, minorFont, majorFontEa, minorFontEa };
 }
 function defaultColorScheme() {
@@ -194,26 +386,26 @@ function defaultColorScheme() {
 }
 
 // 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`);
+  const root = parsed.Relationships;
+  if (!root) {
+    debug("relationship.missing", `missing root element "Relationships" in XML`);
     return rels;
   }
-  const relationships = root.Relationships.Relationship;
+  const relationships = root.Relationship;
   if (!relationships) return rels;
   for (const rel of relationships) {
     const id = rel["@_Id"];
     const type = rel["@_Type"];
     const target = rel["@_Target"];
+    const targetMode = rel["@_TargetMode"];
     if (!id || !type || !target) {
-      console.warn(`${WARN_PREFIX3} Relationship: entry missing required attribute, skipping`);
+      debug("relationship.attribute", "entry missing required attribute, skipping");
       continue;
     }
-    rels.set(id, { id, type, target });
+    rels.set(id, { id, type, target, ...targetMode && { targetMode } });
   }
   return rels;
 }
@@ -241,7 +433,6 @@ function resolveRelationshipTarget(basePath, relTarget) {
 }
 
 // src/parser/fill-parser.ts
-var WARN_PREFIX4 = "[pptx-glimpse]";
 function parseFillFromNode(node, colorResolver, context) {
   if (!node) return null;
   if (node.noFill !== void 0) {
@@ -259,10 +450,17 @@ function parseFillFromNode(node, colorResolver, context) {
   if (node.blipFill && context) {
     return parseBlipFill(node.blipFill, context);
   }
+  if (node.pattFill) {
+    return parsePatternFill(node.pattFill, colorResolver);
+  }
+  if (node.grpFill !== void 0 && context?.groupFill) {
+    return context.groupFill;
+  }
   return null;
 }
 function parseBlipFill(blipFillNode, context) {
-  const rId = blipFillNode?.blip?.["@_r:embed"] ?? blipFillNode?.blip?.["@_embed"];
+  const blip = blipFillNode?.blip;
+  const rId = blip?.["@_r:embed"] ?? blip?.["@_embed"];
   if (!rId) return null;
   const rel = context.rels.get(rId);
   if (!rel) return null;
@@ -284,27 +482,54 @@ function parseBlipFill(blipFillNode, context) {
   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`);
+  const gsLst = gradNode.gsLst;
+  const gsArr = gsLst?.gs;
+  if (!gsArr) {
+    debug("gradientFill.gsLst", "GradientFill: gsLst not found, skipping gradient");
     return null;
   }
   const stops = [];
-  for (const gs of gsLst) {
+  for (const gs of gsArr) {
     const position = Number(gs["@_pos"] ?? 0) / 1e5;
     const color = colorResolver.resolve(gs);
     if (color) {
       stops.push({ position, color });
     }
   }
+  const pathNode = gradNode.path;
+  if (pathNode) {
+    const fillToRect = pathNode.fillToRect;
+    let centerX = 0.5;
+    let centerY = 0.5;
+    if (fillToRect) {
+      const l = Number(fillToRect["@_l"] ?? 0);
+      const t = Number(fillToRect["@_t"] ?? 0);
+      const r = Number(fillToRect["@_r"] ?? 0);
+      const b = Number(fillToRect["@_b"] ?? 0);
+      centerX = (l + (1e5 - r)) / 2 / 1e5;
+      centerY = (t + (1e5 - b)) / 2 / 1e5;
+    }
+    return { type: "gradient", stops, angle: 0, gradientType: "radial", centerX, centerY };
+  }
   let angle = 0;
-  if (gradNode.lin) {
-    angle = Number(gradNode.lin["@_ang"] ?? 0) / 6e4;
+  const lin = gradNode.lin;
+  if (lin) {
+    angle = Number(lin["@_ang"] ?? 0) / 6e4;
   }
-  return { type: "gradient", stops, angle };
+  return { type: "gradient", stops, angle, gradientType: "linear" };
+}
+function parsePatternFill(pattNode, colorResolver) {
+  const preset = pattNode["@_prst"] ?? "ltDnDiag";
+  const fgColor = pattNode.fgClr ? colorResolver.resolve(pattNode.fgClr) : null;
+  const bgColor = pattNode.bgClr ? colorResolver.resolve(pattNode.bgClr) : null;
+  if (!fgColor || !bgColor) return null;
+  return { type: "pattern", preset, foregroundColor: fgColor, backgroundColor: bgColor };
 }
 function parseOutline(lnNode, colorResolver) {
   if (!lnNode) return null;
+  if (lnNode.pattFill) {
+    warn("ln.pattFill", "pattern line fill not implemented");
+  }
   const width = Number(lnNode["@_w"] ?? 12700);
   let fill = null;
   if (lnNode.solidFill) {
@@ -312,12 +537,61 @@ function parseOutline(lnNode, colorResolver) {
     if (color) {
       fill = { type: "solid", color };
     }
+  } else if (lnNode.gradFill) {
+    const gradFill = parseGradientFill(lnNode.gradFill, colorResolver);
+    if (gradFill && gradFill.type === "gradient") {
+      fill = gradFill;
+    }
   }
   if (lnNode.noFill !== void 0) {
     return null;
   }
-  const dashStyle = lnNode.prstDash?.["@_val"] ?? "solid";
-  return { width, fill, dashStyle };
+  const prstDash = lnNode.prstDash;
+  const dashStyle = prstDash?.["@_val"] ?? "solid";
+  const customDash = parseCustomDash(lnNode);
+  const lineCap = parseLineCap(lnNode["@_cap"]);
+  const lineJoin = parseLineJoin(lnNode);
+  const headEnd = parseArrowEndpoint(lnNode.headEnd);
+  const tailEnd = parseArrowEndpoint(lnNode.tailEnd);
+  return { width, fill, dashStyle, customDash, lineCap, lineJoin, headEnd, tailEnd };
+}
+function parseCustomDash(lnNode) {
+  const custDash = lnNode.custDash;
+  if (!custDash) return void 0;
+  const dsArr = custDash.ds;
+  if (!dsArr || dsArr.length === 0) return void 0;
+  const result = [];
+  for (const ds of dsArr) {
+    const d = Number(ds["@_d"] ?? 1e5) / 1e5;
+    const sp = Number(ds["@_sp"] ?? 1e5) / 1e5;
+    result.push(d, sp);
+  }
+  return result;
+}
+var LINE_CAP_MAP = {
+  flat: "butt",
+  sq: "square",
+  rnd: "round"
+};
+function parseLineCap(cap) {
+  if (!cap) return void 0;
+  return LINE_CAP_MAP[cap];
+}
+function parseLineJoin(lnNode) {
+  if (lnNode.round !== void 0) return "round";
+  if (lnNode.bevel !== void 0) return "bevel";
+  if (lnNode.miter !== void 0) return "miter";
+  return void 0;
+}
+function parseArrowEndpoint(node) {
+  if (!node) return null;
+  const type = node["@_type"] ?? "none";
+  if (type === "none") return null;
+  return {
+    type,
+    width: node["@_w"] ?? "med",
+    length: node["@_len"] ?? "med"
+  };
 }
 
 // src/parser/effect-parser.ts
@@ -381,8 +655,12 @@ var CHART_TYPE_MAP = [
   ["line3DChart", "line"],
   ["pieChart", "pie"],
   ["pie3DChart", "pie"],
-  ["doughnutChart", "pie"],
-  ["scatterChart", "scatter"]
+  ["doughnutChart", "doughnut"],
+  ["scatterChart", "scatter"],
+  ["bubbleChart", "bubble"],
+  ["areaChart", "area"],
+  ["area3DChart", "area"],
+  ["radarChart", "radar"]
 ];
 function parseChart(chartXml, colorResolver) {
   const parsed = parseXml(chartXml);
@@ -393,10 +671,7 @@ function parseChart(chartXml, colorResolver) {
   const plotArea = chart.plotArea;
   if (!plotArea) return null;
   const title = parseChartTitle(chart.title);
-  const { chartType, series, categories, barDirection } = parseChartTypeAndData(
-    plotArea,
-    colorResolver
-  );
+  const { chartType, series, categories, barDirection, holeSize, radarStyle } = parseChartTypeAndData(plotArea, colorResolver);
   if (!chartType) return null;
   const legend = parseLegend(chart.legend);
   return {
@@ -405,6 +680,8 @@ function parseChart(chartXml, colorResolver) {
     series,
     categories,
     ...barDirection !== void 0 && { barDirection },
+    ...holeSize !== void 0 && { holeSize },
+    ...radarStyle !== void 0 && { radarStyle },
     legend
   };
 }
@@ -414,30 +691,46 @@ function parseChartTypeAndData(plotArea, colorResolver) {
     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 };
+    const barDirNode = chartNode.barDir;
+    const barDirection = chartType === "bar" ? barDirNode?.["@_val"] ?? "col" : void 0;
+    const holeSizeNode = chartNode.holeSize;
+    const holeSize = chartType === "doughnut" ? Number(holeSizeNode?.["@_val"] ?? 50) : void 0;
+    const radarStyleNode = chartNode.radarStyle;
+    const radarStyle = chartType === "radar" ? radarStyleNode?.["@_val"] ?? "standard" : void 0;
+    return { chartType, series, categories, barDirection, holeSize, radarStyle };
+  }
+  const knownTags = new Set(CHART_TYPE_MAP.map(([tag]) => tag));
+  const chartTags = ["surfaceChart", "surface3DChart", "stockChart", "ofPieChart"];
+  for (const tag of chartTags) {
+    if (!knownTags.has(tag) && plotArea[tag]) {
+      warn(`chart.${tag}`, `chart type "${tag}" not implemented`);
+      break;
+    }
   }
   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 usesXY = chartType === "scatter" || chartType === "bubble";
+  const values = parseNumericData(usesXY ? ser.yVal : ser.val);
+  const xValues = usesXY ? parseNumericData(ser.xVal) : void 0;
+  const bubbleSizes = chartType === "bubble" ? parseNumericData(ser.bubbleSize) : void 0;
   const color = resolveSeriesColor(ser.spPr, seriesIndex, colorResolver);
   return {
     name,
     values,
     ...xValues !== void 0 && { xValues },
+    ...bubbleSizes !== void 0 && { bubbleSizes },
     color
   };
 }
 function parseSeriesName(tx) {
   if (!tx) return null;
-  const strCache = tx.strRef?.strCache;
+  const strRef = tx.strRef;
+  const strCache = strRef?.strCache;
   if (strCache?.pt) {
     const pts = strCache.pt;
     return pts[0]?.v ?? null;
@@ -447,7 +740,8 @@ function parseSeriesName(tx) {
 }
 function parseNumericData(valNode) {
   if (!valNode) return [];
-  const numCache = valNode.numRef?.numCache;
+  const numRef = valNode.numRef;
+  const numCache = 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));
@@ -456,7 +750,9 @@ function extractCategories(serList) {
   for (const ser of serList) {
     const cat = ser.cat;
     if (!cat) continue;
-    const strCache = cat.strRef?.strCache ?? cat.numRef?.numCache;
+    const strRef = cat.strRef;
+    const numRef = cat.numRef;
+    const strCache = strRef?.strCache ?? numRef?.numCache;
     if (strCache?.pt) {
       return strCache.pt.slice().sort((a, b) => Number(a["@_idx"]) - Number(b["@_idx"])).map((pt) => String(pt.v ?? ""));
     }
@@ -474,7 +770,8 @@ function resolveSeriesColor(spPr, seriesIndex, colorResolver) {
 }
 function parseChartTitle(titleNode) {
   if (!titleNode) return null;
-  const rich = titleNode.tx?.rich;
+  const tx = titleNode.tx;
+  const rich = tx?.rich;
   if (!rich?.p) return null;
   const pList = Array.isArray(rich.p) ? rich.p : [rich.p];
   const texts = [];
@@ -483,23 +780,303 @@ function parseChartTitle(titleNode) {
     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"]));
+      else if (t && 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";
+  const legendPos = legendNode.legendPos;
+  const pos = legendPos?.["@_val"] ?? "b";
   return { position: pos };
 }
 
+// src/parser/geometry-formula.ts
+function createBuiltinVariables(w, h) {
+  return {
+    w,
+    h,
+    l: 0,
+    t: 0,
+    r: w,
+    b: h,
+    wd2: w / 2,
+    hd2: h / 2,
+    wd4: w / 4,
+    hd4: h / 4,
+    wd5: w / 5,
+    hd5: h / 5,
+    wd6: w / 6,
+    hd6: h / 6,
+    wd8: w / 8,
+    hd8: h / 8,
+    wd10: w / 10,
+    hd10: h / 10,
+    wd12: w / 12,
+    hd12: h / 12,
+    wd32: w / 32,
+    hd32: h / 32,
+    ss: Math.min(w, h),
+    ls: Math.max(w, h),
+    ssd2: Math.min(w, h) / 2,
+    ssd4: Math.min(w, h) / 4,
+    ssd6: Math.min(w, h) / 6,
+    ssd8: Math.min(w, h) / 8,
+    ssd16: Math.min(w, h) / 16,
+    ssd32: Math.min(w, h) / 32,
+    cd2: 108e5,
+    cd4: 54e5,
+    cd8: 27e5,
+    "3cd4": 162e5,
+    "3cd8": 81e5,
+    "5cd8": 135e5,
+    "7cd8": 189e5
+  };
+}
+function evaluateFormula(fmla, vars) {
+  const tokens = fmla.trim().split(/\s+/);
+  const op = tokens[0];
+  const resolve = (token) => {
+    if (token === void 0) return 0;
+    const num = Number(token);
+    return Number.isNaN(num) ? vars[token] ?? 0 : num;
+  };
+  switch (op) {
+    case "val":
+      return resolve(tokens[1]);
+    case "+-":
+      return resolve(tokens[1]) + resolve(tokens[2]) - resolve(tokens[3]);
+    case "*/":
+      return Math.round(resolve(tokens[1]) * resolve(tokens[2]) / (resolve(tokens[3]) || 1));
+    case "+/":
+      return Math.round((resolve(tokens[1]) + resolve(tokens[2])) / (resolve(tokens[3]) || 1));
+    case "sin": {
+      const a = resolve(tokens[1]);
+      const b = resolve(tokens[2]);
+      return Math.round(a * Math.sin(b / 6e4 * (Math.PI / 180)));
+    }
+    case "cos": {
+      const a = resolve(tokens[1]);
+      const b = resolve(tokens[2]);
+      return Math.round(a * Math.cos(b / 6e4 * (Math.PI / 180)));
+    }
+    case "tan": {
+      const a = resolve(tokens[1]);
+      const b = resolve(tokens[2]);
+      const tanVal = Math.tan(b / 6e4 * (Math.PI / 180));
+      return Math.round(a * tanVal);
+    }
+    case "at2": {
+      const x = resolve(tokens[1]);
+      const y = resolve(tokens[2]);
+      return Math.round(Math.atan2(y, x) * (180 / Math.PI) * 6e4);
+    }
+    case "sqrt":
+      return Math.round(Math.sqrt(resolve(tokens[1])));
+    case "min":
+      return Math.min(resolve(tokens[1]), resolve(tokens[2]));
+    case "max":
+      return Math.max(resolve(tokens[1]), resolve(tokens[2]));
+    case "abs":
+      return Math.abs(resolve(tokens[1]));
+    case "pin": {
+      const lo = resolve(tokens[1]);
+      const val = resolve(tokens[2]);
+      const hi = resolve(tokens[3]);
+      return Math.max(lo, Math.min(hi, val));
+    }
+    case "mod": {
+      const a = resolve(tokens[1]);
+      const b = resolve(tokens[2]);
+      const c = resolve(tokens[3]);
+      return Math.round(Math.sqrt(a * a + b * b + c * c));
+    }
+    case "cat2": {
+      const a = resolve(tokens[1]);
+      const b = resolve(tokens[2]);
+      const c = resolve(tokens[3]);
+      return Math.round(a * Math.cos(Math.atan2(c, b)));
+    }
+    case "sat2": {
+      const a = resolve(tokens[1]);
+      const b = resolve(tokens[2]);
+      const c = resolve(tokens[3]);
+      return Math.round(a * Math.sin(Math.atan2(c, b)));
+    }
+    case "?:":
+      return resolve(tokens[1]) > 0 ? resolve(tokens[2]) : resolve(tokens[3]);
+    default:
+      return 0;
+  }
+}
+function evaluateGuides(avLst, gdLst, w, h) {
+  const vars = createBuiltinVariables(w, h);
+  for (const gd of avLst) {
+    vars[gd.name] = evaluateFormula(gd.fmla, vars);
+  }
+  for (const gd of gdLst) {
+    vars[gd.name] = evaluateFormula(gd.fmla, vars);
+  }
+  return vars;
+}
+function resolveValue(val, vars) {
+  if (typeof val === "number") return val;
+  const num = Number(val);
+  if (!Number.isNaN(num)) return num;
+  return vars[val] ?? 0;
+}
+
+// src/parser/custom-geometry-parser.ts
+function parseCustomGeometry(custGeom) {
+  const pathLst = custGeom.pathLst;
+  if (!pathLst?.path) return null;
+  const avLst = custGeom.avLst;
+  const gdLst = custGeom.gdLst;
+  const avGd = parseGuideList(avLst?.gd);
+  const gdGd = parseGuideList(gdLst?.gd);
+  const paths = Array.isArray(pathLst.path) ? pathLst.path : [pathLst.path];
+  const result = [];
+  for (const path of paths) {
+    const w = Number(path["@_w"] ?? 0);
+    const h = Number(path["@_h"] ?? 0);
+    if (w === 0 && h === 0) continue;
+    const vars = evaluateGuides(avGd, gdGd, w, h);
+    const commands = buildPathCommands(path, vars);
+    if (!commands) continue;
+    result.push({ width: w, height: h, commands });
+  }
+  return result.length > 0 ? result : null;
+}
+function parseGuideList(gd) {
+  if (!gd) return [];
+  const list = Array.isArray(gd) ? gd : [gd];
+  return list.map((g) => ({
+    name: g["@_name"] ?? "",
+    fmla: g["@_fmla"] ?? ""
+  })).filter((g) => g.name && g.fmla);
+}
+function buildPathCommands(path, vars) {
+  const parts = [];
+  let curX = 0;
+  let curY = 0;
+  let startX = 0;
+  let startY = 0;
+  for (const key of Object.keys(path)) {
+    if (key.startsWith("@_")) continue;
+    const value = path[key];
+    const items = Array.isArray(value) ? value : [value];
+    for (const item of items) {
+      switch (key) {
+        case "moveTo": {
+          const pt = resolveFirstPoint(item.pt, vars);
+          if (pt) {
+            parts.push(`M ${pt.x} ${pt.y}`);
+            curX = pt.x;
+            curY = pt.y;
+            startX = pt.x;
+            startY = pt.y;
+          }
+          break;
+        }
+        case "lnTo": {
+          const pt = resolveFirstPoint(item.pt, vars);
+          if (pt) {
+            parts.push(`L ${pt.x} ${pt.y}`);
+            curX = pt.x;
+            curY = pt.y;
+          }
+          break;
+        }
+        case "cubicBezTo": {
+          const pts = resolvePoints(item.pt, vars);
+          if (pts.length >= 3) {
+            parts.push(`C ${pts.map((p) => `${p.x} ${p.y}`).join(", ")}`);
+            curX = pts[pts.length - 1].x;
+            curY = pts[pts.length - 1].y;
+          }
+          break;
+        }
+        case "quadBezTo": {
+          const pts = resolvePoints(item.pt, vars);
+          if (pts.length >= 2) {
+            parts.push(`Q ${pts.map((p) => `${p.x} ${p.y}`).join(", ")}`);
+            curX = pts[pts.length - 1].x;
+            curY = pts[pts.length - 1].y;
+          }
+          break;
+        }
+        case "arcTo": {
+          const arcResult = convertArcTo(item, curX, curY, vars);
+          if (arcResult) {
+            parts.push(arcResult.svg);
+            curX = arcResult.endX;
+            curY = arcResult.endY;
+          }
+          break;
+        }
+        case "close": {
+          parts.push("Z");
+          curX = startX;
+          curY = startY;
+          break;
+        }
+      }
+    }
+  }
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+function resolveFirstPoint(pt, vars) {
+  if (!pt) return null;
+  const p = Array.isArray(pt) ? pt[0] : pt;
+  if (!p) return null;
+  return {
+    x: resolveValue(p["@_x"], vars),
+    y: resolveValue(p["@_y"], vars)
+  };
+}
+function resolvePoints(pt, vars) {
+  if (!pt) return [];
+  const pts = Array.isArray(pt) ? pt : [pt];
+  return pts.map((p) => ({
+    x: resolveValue(p["@_x"], vars),
+    y: resolveValue(p["@_y"], vars)
+  }));
+}
+function convertArcTo(arc, curX, curY, vars) {
+  const wR = resolveValue(arc["@_wR"] ?? "0", vars);
+  const hR = resolveValue(arc["@_hR"] ?? "0", vars);
+  const stAng = resolveValue(arc["@_stAng"] ?? "0", vars);
+  const swAng = resolveValue(arc["@_swAng"] ?? "0", vars);
+  if (wR === 0 && hR === 0) return null;
+  if (swAng === 0) return null;
+  const stAngDeg = stAng / 6e4;
+  const swAngDeg = swAng / 6e4;
+  const stAngRad = stAngDeg * Math.PI / 180;
+  const endAngRad = (stAngDeg + swAngDeg) * Math.PI / 180;
+  const cx = curX - wR * Math.cos(stAngRad);
+  const cy = curY - hR * Math.sin(stAngRad);
+  const endX = cx + wR * Math.cos(endAngRad);
+  const endY = cy + hR * Math.sin(endAngRad);
+  const largeArcFlag = Math.abs(swAngDeg) > 180 ? 1 : 0;
+  const sweepFlag = swAngDeg > 0 ? 1 : 0;
+  const rx = Math.round(wR * 1e3) / 1e3;
+  const ry = Math.round(hR * 1e3) / 1e3;
+  const ex = Math.round(endX * 1e3) / 1e3;
+  const ey = Math.round(endY * 1e3) / 1e3;
+  return {
+    svg: `A ${rx} ${ry} 0 ${largeArcFlag} ${sweepFlag} ${ex} ${ey}`,
+    endX,
+    endY
+  };
+}
+
 // src/parser/table-parser.ts
-function parseTable(tblNode, colorResolver) {
+function parseTable(tblNode, colorResolver, fontScheme) {
   if (!tblNode) return null;
   const columns = parseColumns(tblNode.tblGrid);
   if (columns.length === 0) return null;
-  const rows = parseRows(tblNode.tr, colorResolver);
+  const rows = parseRows(tblNode.tr, colorResolver, fontScheme);
   return { rows, columns };
 }
 function parseColumns(tblGrid) {
@@ -509,21 +1086,23 @@ function parseColumns(tblGrid) {
     width: Number(col["@_w"] ?? 0)
   }));
 }
-function parseRows(trList, colorResolver) {
+function parseRows(trList, colorResolver, fontScheme) {
   if (!trList) return [];
+  const trArr = Array.isArray(trList) ? trList : [trList];
   const rows = [];
-  for (const tr of trList) {
+  for (const tr of trArr) {
     const height = Number(tr["@_h"] ?? 0);
-    const cells = parseCells(tr.tc, colorResolver);
+    const cells = parseCells(tr.tc, colorResolver, fontScheme);
     rows.push({ height, cells });
   }
   return rows;
 }
-function parseCells(tcList, colorResolver) {
+function parseCells(tcList, colorResolver, fontScheme) {
   if (!tcList) return [];
+  const tcArr = Array.isArray(tcList) ? tcList : [tcList];
   const cells = [];
-  for (const tc of tcList) {
-    const textBody = parseTextBody(tc.txBody, colorResolver);
+  for (const tc of tcArr) {
+    const textBody = parseTextBody(tc.txBody, colorResolver, void 0, fontScheme);
     const tcPr = tc.tcPr;
     const fill = tcPr ? parseFillFromNode(tcPr, colorResolver) : null;
     const borders = tcPr ? parseCellBorders(tcPr, colorResolver) : null;
@@ -544,41 +1123,46 @@ function parseCellBorders(tcPr, colorResolver) {
   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) {
+var SHAPE_TAGS = /* @__PURE__ */ new Set(["sp", "pic", "cxnSp", "grpSp", "graphicFrame"]);
+function navigateOrdered(ordered, path) {
+  let current = ordered;
+  for (const key of path) {
+    const entry = current.find((item) => key in item);
+    if (!entry) return null;
+    current = entry[key];
+    if (!Array.isArray(current)) return null;
+  }
+  return current;
+}
+function parseSlide(slideXml, slidePath, slideNumber, archive, colorResolver, fontScheme) {
   const parsed = parseXml(slideXml);
   const sld = parsed.sld;
   if (!sld) {
-    console.warn(`${WARN_PREFIX5} Slide ${slideNumber}: missing root element "sld" in XML`);
+    debug("slide.missing", `missing root element "sld" in XML`, `Slide ${slideNumber}`);
   }
   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 cSld = sld?.cSld ?? void 0;
+  const background = parseBackground(cSld?.bg, colorResolver, fillContext);
+  const orderedParsed = parseXmlOrdered(slideXml);
+  const orderedSpTree = navigateOrdered(orderedParsed, ["sld", "cSld", "spTree"]);
   const elements = parseShapeTree(
-    sld?.cSld?.spTree,
+    cSld?.spTree,
     rels,
     slidePath,
     archive,
     colorResolver,
-    `Slide ${slideNumber}`
+    `Slide ${slideNumber}`,
+    fillContext,
+    fontScheme,
+    orderedSpTree
   );
-  return { slideNumber, background, elements };
+  const showMasterSpAttr = sld?.["@_showMasterSp"];
+  const showMasterSp = showMasterSpAttr !== "0" && showMasterSpAttr !== "false";
+  return { slideNumber, background, elements, showMasterSp };
 }
 function parseBackground(bgNode, colorResolver, context) {
   if (!bgNode) return null;
@@ -587,17 +1171,51 @@ function parseBackground(bgNode, colorResolver, context) {
   const fill = parseFillFromNode(bgPr, colorResolver, context);
   return { fill };
 }
-function parseShapeTree(spTree, rels, slidePath, archive, colorResolver, context) {
+function mergeChildElements(spTree, source) {
+  const tags = ["sp", "pic", "cxnSp", "grpSp", "graphicFrame"];
+  for (const tag of tags) {
+    const items = source[tag];
+    if (!items) continue;
+    if (!spTree[tag]) {
+      spTree[tag] = [];
+    }
+    const arr = Array.isArray(items) ? items : [items];
+    for (const item of arr) {
+      spTree[tag].push(item);
+    }
+  }
+}
+function parseShapeTree(spTree, rels, slidePath, archive, colorResolver, context, fillContext, fontScheme, orderedChildren) {
   if (!spTree) return [];
+  if (orderedChildren) {
+    return parseShapeTreeOrdered(
+      spTree,
+      orderedChildren,
+      rels,
+      slidePath,
+      archive,
+      colorResolver,
+      context,
+      fillContext,
+      fontScheme
+    );
+  }
+  const alternateContents = spTree.AlternateContent ?? [];
+  for (const ac of alternateContents) {
+    const choices = Array.isArray(ac.Choice) ? ac.Choice : ac.Choice ? [ac.Choice] : [];
+    for (const choice of choices) {
+      mergeChildElements(spTree, choice);
+    }
+  }
   const ctx = context ?? slidePath;
   const elements = [];
   const shapes = spTree.sp ?? [];
   for (const sp of shapes) {
-    const shape = parseShape(sp, colorResolver);
+    const shape = parseShape(sp, colorResolver, rels, fillContext, fontScheme);
     if (shape) {
       elements.push(shape);
     } else {
-      console.warn(`${WARN_PREFIX5} ${ctx}: shape skipped (parse returned null)`);
+      debug("shape.skipped", "shape skipped (parse returned null)", ctx);
     }
   }
   const pics = spTree.pic ?? [];
@@ -606,7 +1224,7 @@ function parseShapeTree(spTree, rels, slidePath, archive, colorResolver, context
     if (img) {
       elements.push(img);
     } else {
-      console.warn(`${WARN_PREFIX5} ${ctx}: image skipped (parse returned null)`);
+      debug("image.skipped", "image skipped (parse returned null)", ctx);
     }
   }
   const cxnSps = spTree.cxnSp ?? [];
@@ -615,40 +1233,201 @@ function parseShapeTree(spTree, rels, slidePath, archive, colorResolver, context
     if (connector) {
       elements.push(connector);
     } else {
-      console.warn(`${WARN_PREFIX5} ${ctx}: connector skipped (parse returned null)`);
+      debug("connector.skipped", "connector skipped (parse returned null)", ctx);
     }
   }
   const grpSps = spTree.grpSp ?? [];
   for (const grp of grpSps) {
-    const group = parseGroup(grp, rels, slidePath, archive, colorResolver);
+    const group = parseGroup(grp, rels, slidePath, archive, colorResolver, fillContext, fontScheme);
     if (group) {
       elements.push(group);
     } else {
-      console.warn(`${WARN_PREFIX5} ${ctx}: group skipped (parse returned null)`);
+      debug("group.skipped", "group skipped (parse returned null)", ctx);
     }
   }
   const graphicFrames = spTree.graphicFrame ?? [];
   for (const gf of graphicFrames) {
-    const chart = parseGraphicFrame(gf, rels, slidePath, archive, colorResolver);
+    const chart = parseGraphicFrame(gf, rels, slidePath, archive, colorResolver, fontScheme);
     if (chart) {
       elements.push(chart);
     } else {
-      console.warn(`${WARN_PREFIX5} ${ctx}: graphicFrame skipped (parse returned null)`);
+      debug("graphicFrame.skipped", "graphicFrame skipped (parse returned null)", ctx);
+    }
+  }
+  return elements;
+}
+function parseShapeTreeOrdered(spTree, orderedChildren, rels, slidePath, archive, colorResolver, context, fillContext, fontScheme) {
+  const ctx = context ?? slidePath;
+  const elements = [];
+  const tagCounters = {};
+  for (const child of orderedChildren) {
+    const tag = Object.keys(child).find((k) => k !== ":@");
+    if (!tag) continue;
+    if (tag === "AlternateContent") {
+      const acIndex = tagCounters["AlternateContent"] ?? 0;
+      tagCounters["AlternateContent"] = acIndex + 1;
+      const acList = spTree.AlternateContent ?? [];
+      const acData = acList[acIndex];
+      if (!acData) continue;
+      const choices = Array.isArray(acData.Choice) ? acData.Choice : acData.Choice ? [acData.Choice] : [];
+      const firstChoice = choices[0];
+      if (!firstChoice) continue;
+      const acOrderedChildren = child.AlternateContent;
+      const choiceOrdered = Array.isArray(acOrderedChildren) ? acOrderedChildren.find((c) => "Choice" in c) : null;
+      const choiceChildren = choiceOrdered?.Choice;
+      if (Array.isArray(choiceChildren)) {
+        const choiceTagCounters = {};
+        for (const choiceChild of choiceChildren) {
+          const choiceTag = Object.keys(choiceChild).find((k) => k !== ":@");
+          if (!choiceTag || !SHAPE_TAGS.has(choiceTag)) continue;
+          const choiceIdx = choiceTagCounters[choiceTag] ?? 0;
+          choiceTagCounters[choiceTag] = choiceIdx + 1;
+          const items = firstChoice[choiceTag];
+          const arr = Array.isArray(items) ? items : items ? [items] : [];
+          const element2 = arr[choiceIdx];
+          if (!element2) continue;
+          parseAndPushElement(
+            choiceTag,
+            element2,
+            choiceChild,
+            elements,
+            rels,
+            slidePath,
+            archive,
+            colorResolver,
+            ctx,
+            fillContext,
+            fontScheme
+          );
+        }
+      }
+      continue;
     }
+    if (!SHAPE_TAGS.has(tag)) continue;
+    const index = tagCounters[tag] ?? 0;
+    tagCounters[tag] = index + 1;
+    const tagArray = spTree[tag];
+    const element = tagArray?.[index];
+    if (!element) continue;
+    parseAndPushElement(
+      tag,
+      element,
+      child,
+      elements,
+      rels,
+      slidePath,
+      archive,
+      colorResolver,
+      ctx,
+      fillContext,
+      fontScheme
+    );
   }
   return elements;
 }
-function parseShape(sp, colorResolver) {
+function parseAndPushElement(tag, element, orderedNode, elements, rels, slidePath, archive, colorResolver, ctx, fillContext, fontScheme) {
+  switch (tag) {
+    case "sp": {
+      const shape = parseShape(element, colorResolver, rels, fillContext, fontScheme, orderedNode);
+      if (shape) {
+        elements.push(shape);
+      } else {
+        debug("shape.skipped", "shape skipped (parse returned null)", ctx);
+      }
+      break;
+    }
+    case "pic": {
+      const img = parseImage(element, rels, slidePath, archive, colorResolver);
+      if (img) {
+        elements.push(img);
+      } else {
+        debug("image.skipped", "image skipped (parse returned null)", ctx);
+      }
+      break;
+    }
+    case "cxnSp": {
+      const connector = parseConnector(element, colorResolver);
+      if (connector) {
+        elements.push(connector);
+      } else {
+        debug("connector.skipped", "connector skipped (parse returned null)", ctx);
+      }
+      break;
+    }
+    case "grpSp": {
+      const grpOrderedChildren = orderedNode[tag] ?? null;
+      const group = parseGroup(
+        element,
+        rels,
+        slidePath,
+        archive,
+        colorResolver,
+        fillContext,
+        fontScheme,
+        grpOrderedChildren
+      );
+      if (group) {
+        elements.push(group);
+      } else {
+        debug("group.skipped", "group skipped (parse returned null)", ctx);
+      }
+      break;
+    }
+    case "graphicFrame": {
+      const gfResult = parseGraphicFrame(
+        element,
+        rels,
+        slidePath,
+        archive,
+        colorResolver,
+        fontScheme
+      );
+      if (gfResult) {
+        elements.push(gfResult);
+      } else {
+        debug("graphicFrame.skipped", "graphicFrame skipped (parse returned null)", ctx);
+      }
+      break;
+    }
+  }
+}
+function parseShape(sp, colorResolver, rels, fillContext, fontScheme, orderedNode) {
   const spPr = sp.spPr;
   if (!spPr) return null;
   const transform = parseTransform(spPr.xfrm);
   if (!transform) return null;
+  if (sp.style) {
+    warn("sp.style", "shape style references (lnRef/fillRef/effectRef) not implemented");
+  }
+  if (spPr.scene3d) {
+    warn("spPr.scene3d", "3D scene/camera not implemented");
+  }
+  if (spPr.sp3d) {
+    warn("spPr.sp3d", "3D extrusion/bevel not implemented");
+  }
   const geometry = parseGeometry(spPr);
-  const fill = parseFillFromNode(spPr, colorResolver);
+  const fill = parseFillFromNode(spPr, colorResolver, fillContext);
   const outline = parseOutline(spPr.ln, colorResolver);
-  const textBody = parseTextBody(sp.txBody, colorResolver);
+  let orderedTxBody;
+  if (orderedNode) {
+    const spChildren = orderedNode.sp;
+    if (Array.isArray(spChildren)) {
+      const txBodyEntry = spChildren.find((c) => "txBody" in c);
+      orderedTxBody = txBodyEntry?.txBody;
+    }
+  }
+  const textBody = parseTextBody(
+    sp.txBody,
+    colorResolver,
+    rels,
+    fontScheme,
+    void 0,
+    orderedTxBody
+  );
   const effects = parseEffectList(spPr.effectLst, colorResolver);
-  const ph = sp.nvSpPr?.nvPr?.ph;
+  const nvSpPr = sp.nvSpPr;
+  const nvPr = nvSpPr?.nvPr;
+  const ph = nvPr?.ph;
   const placeholderType = ph ? ph["@_type"] ?? "body" : void 0;
   const placeholderIdx = ph?.["@_idx"] !== void 0 ? Number(ph["@_idx"]) : void 0;
   return {
@@ -669,7 +1448,8 @@ function parseImage(pic, rels, slidePath, archive, colorResolver) {
   const transform = parseTransform(spPr.xfrm);
   if (!transform) return null;
   const blipFill = pic.blipFill;
-  const rId = blipFill?.blip?.["@_r:embed"] ?? blipFill?.blip?.["@_embed"];
+  const blip = blipFill?.blip;
+  const rId = blip?.["@_r:embed"] ?? blip?.["@_embed"];
   if (!rId) return null;
   const rel = rels.get(rId);
   if (!rel) return null;
@@ -689,30 +1469,43 @@ function parseImage(pic, rels, slidePath, archive, colorResolver) {
   const mimeType = mimeMap[ext] ?? "image/png";
   const imageData = mediaData.toString("base64");
   const effects = parseEffectList(spPr.effectLst, colorResolver);
+  const srcRect = parseSrcRect(blipFill?.srcRect);
   return {
     type: "image",
     transform,
     imageData,
     mimeType,
-    effects
+    effects,
+    srcRect
   };
 }
+function parseSrcRect(node) {
+  if (!node) return null;
+  const l = Number(node["@_l"] ?? 0) / 1e5;
+  const t = Number(node["@_t"] ?? 0) / 1e5;
+  const r = Number(node["@_r"] ?? 0) / 1e5;
+  const b = Number(node["@_b"] ?? 0) / 1e5;
+  if (l === 0 && t === 0 && r === 0 && b === 0) return null;
+  return { left: l, top: t, right: r, bottom: b };
+}
 function parseConnector(cxn, colorResolver) {
   const spPr = cxn.spPr;
   if (!spPr) return null;
   const transform = parseTransform(spPr.xfrm);
   if (!transform) return null;
+  const geometry = parseGeometry(spPr);
   const outline = parseOutline(spPr.ln, colorResolver);
   const effects = parseEffectList(spPr.effectLst, colorResolver);
-  return { type: "connector", transform, outline, effects };
+  return { type: "connector", transform, geometry, outline, effects };
 }
-function parseGroup(grp, rels, slidePath, archive, colorResolver) {
+function parseGroup(grp, rels, slidePath, archive, colorResolver, parentFillContext, fontScheme, orderedChildren) {
   const grpSpPr = grp.grpSpPr;
   if (!grpSpPr) return null;
-  const transform = parseTransform(grpSpPr.xfrm);
+  const xfrm = grpSpPr.xfrm;
+  const transform = parseTransform(xfrm);
   if (!transform) return null;
-  const childOff = grpSpPr.xfrm?.chOff;
-  const childExt = grpSpPr.xfrm?.chExt;
+  const childOff = xfrm?.chOff;
+  const childExt = xfrm?.chExt;
   const childTransform = {
     offsetX: Number(childOff?.["@_x"] ?? 0),
     offsetY: Number(childOff?.["@_y"] ?? 0),
@@ -722,15 +1515,33 @@ function parseGroup(grp, rels, slidePath, archive, colorResolver) {
     flipH: false,
     flipV: false
   };
-  const children = parseShapeTree(grp, rels, slidePath, archive, colorResolver);
+  const groupFill = parseFillFromNode(grpSpPr, colorResolver, parentFillContext);
+  const childFillContext = {
+    rels: parentFillContext?.rels ?? rels,
+    archive: parentFillContext?.archive ?? { files: /* @__PURE__ */ new Map(), media: /* @__PURE__ */ new Map() },
+    basePath: parentFillContext?.basePath ?? slidePath,
+    ...groupFill ? { groupFill } : {}
+  };
+  const children = parseShapeTree(
+    grp,
+    rels,
+    slidePath,
+    archive,
+    colorResolver,
+    void 0,
+    childFillContext,
+    fontScheme,
+    orderedChildren
+  );
   const effects = parseEffectList(grpSpPr.effectLst, colorResolver);
   return { type: "group", transform, childTransform, children, effects };
 }
-function parseGraphicFrame(gf, rels, slidePath, archive, colorResolver) {
+function parseGraphicFrame(gf, rels, slidePath, archive, colorResolver, fontScheme) {
   const xfrm = gf.xfrm;
   const transform = parseTransform(xfrm);
   if (!transform) return null;
-  const graphicData = gf.graphic?.graphicData;
+  const graphic = gf.graphic;
+  const graphicData = graphic?.graphicData;
   if (!graphicData) return null;
   const chartRef = graphicData.chart;
   if (chartRef) {
@@ -747,12 +1558,103 @@ function parseGraphicFrame(gf, rels, slidePath, archive, colorResolver) {
   }
   const tblNode = graphicData.tbl;
   if (tblNode) {
-    const tableData = parseTable(tblNode, colorResolver);
+    const tableData = parseTable(tblNode, colorResolver, fontScheme);
     if (!tableData) return null;
     return { type: "table", transform, table: tableData };
   }
+  if (graphicData["@_uri"] === "http://schemas.openxmlformats.org/drawingml/2006/diagram") {
+    return parseSmartArt(
+      graphicData,
+      transform,
+      rels,
+      slidePath,
+      archive,
+      colorResolver,
+      fontScheme
+    );
+  }
+  const uri = graphicData["@_uri"] ?? "unknown";
+  warn("graphicFrame.unsupported", `unsupported graphicFrame content (uri: ${uri})`);
   return null;
 }
+function parseSmartArt(graphicData, transform, rels, slidePath, archive, colorResolver, fontScheme) {
+  const relIds = graphicData.relIds;
+  if (!relIds) return null;
+  const dmRId = relIds["@_r:dm"] ?? relIds["@_dm"];
+  if (!dmRId) return null;
+  const dmRel = rels.get(dmRId);
+  if (!dmRel) return null;
+  const dataPath = resolveRelationshipTarget(slidePath, dmRel.target);
+  const dataRelsPath = buildRelsPath(dataPath);
+  const dataRelsXml = archive.files.get(dataRelsPath);
+  let drawingPath = null;
+  if (dataRelsXml) {
+    const dataRels = parseRelationships(dataRelsXml);
+    for (const [, rel] of dataRels) {
+      if (rel.type.includes("diagramDrawing")) {
+        drawingPath = resolveRelationshipTarget(dataPath, rel.target);
+        break;
+      }
+    }
+  }
+  if (!drawingPath) {
+    for (const [, rel] of rels) {
+      if (rel.type.includes("diagramDrawing")) {
+        drawingPath = resolveRelationshipTarget(slidePath, rel.target);
+        break;
+      }
+    }
+  }
+  if (!drawingPath) return null;
+  const drawingXml = archive.files.get(drawingPath);
+  if (!drawingXml) return null;
+  const parsed = parseXml(drawingXml);
+  const drawing = parsed.drawing;
+  const spTree = drawing?.spTree;
+  if (!spTree) return null;
+  const drawingRelsPath = buildRelsPath(drawingPath);
+  const drawingRelsXml = archive.files.get(drawingRelsPath);
+  const drawingRels = drawingRelsXml ? parseRelationships(drawingRelsXml) : /* @__PURE__ */ new Map();
+  const grpSpPr = spTree.grpSpPr;
+  const grpXfrm = grpSpPr?.xfrm;
+  const childOff = grpXfrm?.chOff;
+  const childExt = grpXfrm?.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 fillContext = {
+    rels: drawingRels,
+    archive,
+    basePath: drawingPath
+  };
+  const orderedParsed = parseXmlOrdered(drawingXml);
+  const orderedSpTree = navigateOrdered(orderedParsed, ["drawing", "spTree"]);
+  const children = parseShapeTree(
+    spTree,
+    drawingRels,
+    drawingPath,
+    archive,
+    colorResolver,
+    void 0,
+    fillContext,
+    fontScheme,
+    orderedSpTree
+  );
+  if (children.length === 0) return null;
+  return {
+    type: "group",
+    transform,
+    childTransform,
+    children,
+    effects: null
+  };
+}
 function parseTransform(xfrm) {
   if (!xfrm) return null;
   const off = xfrm.off;
@@ -764,23 +1666,23 @@ function parseTransform(xfrm) {
   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`);
+    debug("transform.nan", "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`);
+    debug("transform.nan", "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`);
+    debug("transform.nan", "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`);
+    debug("transform.nan", "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`);
+    debug("transform.nan", "NaN detected in transform rotation, defaulting to 0");
     rotation = 0;
   }
   return {
@@ -795,14 +1697,16 @@ function parseTransform(xfrm) {
 }
 function parseGeometry(spPr) {
   if (spPr.prstGeom) {
-    const preset = spPr.prstGeom["@_prst"] ?? "rect";
-    const avLst = spPr.prstGeom.avLst;
+    const prstGeom = spPr.prstGeom;
+    const preset = prstGeom["@_prst"] ?? "rect";
+    const avLst = 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 gdNode = gd;
+        const name = gdNode["@_name"];
+        const fmla = gdNode["@_fmla"];
         const match = fmla?.match(/val\s+(\d+)/);
         if (name && match) {
           adjustValues[name] = Number(match[1]);
@@ -812,59 +1716,21 @@ function parseGeometry(spPr) {
     return { type: "preset", preset, adjustValues };
   }
   if (spPr.custGeom) {
-    const pathData = parseCustomGeometryPaths(spPr.custGeom);
-    if (pathData) {
-      return { type: "custom", pathData };
+    const paths = parseCustomGeometry(spPr.custGeom);
+    if (paths) {
+      return { type: "custom", paths };
     }
   }
   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) {
+function parseTextBody(txBody, colorResolver, rels, fontScheme, lstStyleOverride, orderedTxBody) {
   if (!txBody) return null;
   const bodyPr = txBody.bodyPr;
+  const vert = bodyPr?.["@_vert"];
+  if (vert && vert !== "horz") {
+    warn("bodyPr@vert", `vertical text (vert="${vert}") not implemented`);
+  }
+  const numCol = bodyPr?.["@_numCol"] ? Math.max(1, Number(bodyPr["@_numCol"])) : 1;
   let autoFit = "noAutofit";
   let fontScale = 1;
   let lnSpcReduction = 0;
@@ -872,8 +1738,9 @@ function parseTextBody(txBody, colorResolver) {
     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;
+      const normNode = normAutofit;
+      fontScale = normNode["@_fontScale"] ? Number(normNode["@_fontScale"]) / 1e5 : 1;
+      lnSpcReduction = normNode["@_lnSpcReduction"] ? Number(normNode["@_lnSpcReduction"]) / 1e5 : 0;
     }
   } else if (bodyPr?.spAutoFit !== void 0) {
     autoFit = "spAutofit";
@@ -887,12 +1754,24 @@ function parseTextBody(txBody, colorResolver) {
     wrap: bodyPr?.["@_wrap"] ?? "square",
     autoFit,
     fontScale,
-    lnSpcReduction
+    lnSpcReduction,
+    numCol
   };
+  const lstStyle = lstStyleOverride ?? parseListStyle(txBody.lstStyle);
+  const orderedParagraphs = [];
+  if (orderedTxBody) {
+    for (const child of orderedTxBody) {
+      if ("p" in child) {
+        orderedParagraphs.push(child.p);
+      }
+    }
+  }
   const paragraphs = [];
   const pList = txBody.p ?? [];
-  for (const p of pList) {
-    paragraphs.push(parseParagraph(p, colorResolver));
+  for (let i = 0; i < pList.length; i++) {
+    paragraphs.push(
+      parseParagraph(pList[i], colorResolver, rels, fontScheme, lstStyle, orderedParagraphs[i])
+    );
   }
   if (paragraphs.length === 0) return null;
   return { paragraphs, bodyProperties };
@@ -911,79 +1790,256 @@ var VALID_AUTO_NUM_SCHEMES = /* @__PURE__ */ new Set([
 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;
+  const buClr = pPr?.buClr;
+  let bulletColor = colorResolver.resolve(buClr);
+  if (!buClr) bulletColor = null;
+  const buSzPct = pPr?.buSzPct;
+  const bulletSizePct = buSzPct ? Number(buSzPct["@_val"]) : null;
   if (pPr?.buNone !== void 0) {
     bullet = { type: "none" };
   } else if (pPr?.buChar) {
-    bullet = { type: "char", char: pPr.buChar["@_char"] ?? "\u2022" };
+    const buChar = pPr.buChar;
+    bullet = { type: "char", char: buChar["@_char"] ?? "\u2022" };
   } else if (pPr?.buAutoNum) {
-    const scheme = pPr.buAutoNum["@_type"] ?? "arabicPeriod";
+    const buAutoNum = pPr.buAutoNum;
+    const scheme = buAutoNum["@_type"] ?? "arabicPeriod";
     bullet = {
       type: "autoNum",
       scheme: VALID_AUTO_NUM_SCHEMES.has(scheme) ? scheme : "arabicPeriod",
-      startAt: Number(pPr.buAutoNum["@_startAt"] ?? 1)
+      startAt: Number(buAutoNum["@_startAt"] ?? 1)
     };
   }
   if (pPr?.buFont) {
-    bulletFont = pPr.buFont["@_typeface"] ?? null;
+    const buFont = pPr.buFont;
+    bulletFont = buFont["@_typeface"] ?? null;
   }
   return { bullet, bulletFont, bulletColor, bulletSizePct };
 }
-function parseParagraph(p, colorResolver) {
+function parseSpacing(spc) {
+  if (spc?.spcPts) {
+    const spcPts = spc.spcPts;
+    return { type: "pts", value: Number(spcPts["@_val"]) };
+  }
+  if (spc?.spcPct) {
+    const spcPct = spc.spcPct;
+    return { type: "pct", value: Number(spcPct["@_val"]) };
+  }
+  return { type: "pts", value: 0 };
+}
+function parseTabStops(pPr) {
+  const tabLst = pPr?.tabLst;
+  if (!tabLst) return [];
+  const tabs = tabLst.tab;
+  if (!tabs) return [];
+  const tabArr = Array.isArray(tabs) ? tabs : [tabs];
+  return tabArr.map((tab) => ({
+    position: Number(tab["@_pos"] ?? 0),
+    alignment: tab["@_algn"] ?? "l"
+  }));
+}
+function extractMathText(node) {
+  let text = "";
+  for (const [key, value] of Object.entries(node)) {
+    if (key.startsWith("@_")) continue;
+    if (key === "t") {
+      if (typeof value === "object" && value !== null) {
+        text += value["#text"] ?? "";
+      } else if (value !== void 0 && value !== null) {
+        text += String(value);
+      }
+    } else if (typeof value === "object" && value !== null) {
+      const items = Array.isArray(value) ? value : [value];
+      for (const item of items) {
+        if (typeof item === "object" && item !== null) {
+          text += extractMathText(item);
+        }
+      }
+    }
+  }
+  return text;
+}
+function extractTextContent(node) {
+  const text = node.t;
+  if (typeof text === "object") {
+    return text["#text"] ?? "";
+  }
+  return text !== void 0 && text !== null ? String(text) : "";
+}
+function parseParagraph(p, colorResolver, rels, fontScheme, lstStyle, orderedPChildren) {
   const pPr = p.pPr;
+  const level = Number(pPr?.["@_lvl"] ?? 0);
+  const lstLevelProps = lstStyle?.levels[level];
   const { bullet, bulletFont, bulletColor, bulletSizePct } = parseBullet(pPr, colorResolver);
+  const lnSpc = pPr?.lnSpc;
+  const lnSpcSpcPct = lnSpc?.spcPct;
+  const tabStops = parseTabStops(pPr);
   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),
+    alignment: pPr?.["@_algn"] ?? lstLevelProps?.alignment ?? "l",
+    lineSpacing: lnSpcSpcPct ? Number(lnSpcSpcPct["@_val"]) : null,
+    spaceBefore: parseSpacing(pPr?.spcBef),
+    spaceAfter: parseSpacing(pPr?.spcAft),
+    level,
     bullet,
     bulletFont,
     bulletColor,
     bulletSizePct,
-    marginLeft: Number(pPr?.["@_marL"] ?? 0),
-    indent: Number(pPr?.["@_indent"] ?? 0)
+    marginLeft: pPr?.["@_marL"] !== void 0 ? Number(pPr["@_marL"]) : lstLevelProps?.marginLeft ?? 0,
+    indent: pPr?.["@_indent"] !== void 0 ? Number(pPr["@_indent"]) : lstLevelProps?.indent ?? 0,
+    tabStops
   };
+  const pPrDefRPr = parseDefaultRunProperties(pPr?.defRPr);
+  const lstDefRPr = lstLevelProps?.defaultRunProperties;
+  const mergedDefaults = mergeDefaultRunProperties(pPrDefRPr, lstDefRPr);
   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 });
+  if (orderedPChildren) {
+    const tagCounters = {};
+    const rList = p.r ?? [];
+    const fldList = p.fld ?? [];
+    const brList = p.br ?? [];
+    for (const child of orderedPChildren) {
+      const tag = Object.keys(child).find((k) => k !== ":@");
+      if (!tag) continue;
+      const idx = tagCounters[tag] ?? 0;
+      tagCounters[tag] = idx + 1;
+      if (tag === "r") {
+        const r = rList[idx];
+        if (r) {
+          const textContent = extractTextContent(r);
+          const rPr = r.rPr;
+          const runProps = parseRunProperties(rPr, colorResolver, rels, fontScheme, mergedDefaults);
+          runs.push({ text: textContent, properties: runProps });
+        }
+      } else if (tag === "fld") {
+        const fld = fldList[idx];
+        if (fld) {
+          const textContent = extractTextContent(fld);
+          const rPr = fld.rPr;
+          const runProps = parseRunProperties(rPr, colorResolver, rels, fontScheme, mergedDefaults);
+          runs.push({ text: textContent, properties: runProps });
+        }
+      } else if (tag === "br") {
+        const br = brList[idx];
+        const rPr = br?.rPr;
+        const runProps = parseRunProperties(rPr, colorResolver, rels, fontScheme, mergedDefaults);
+        runs.push({ text: "\n", properties: runProps });
+      } else if (tag === "m") {
+        const mNode = p.m;
+        if (mNode) {
+          const mData = Array.isArray(mNode) ? mNode[idx] : idx === 0 ? mNode : void 0;
+          if (mData) {
+            const mathText = extractMathText(mData);
+            if (mathText) {
+              const runProps = parseRunProperties(
+                void 0,
+                colorResolver,
+                rels,
+                fontScheme,
+                mergedDefaults
+              );
+              runs.push({ text: mathText, properties: runProps });
+            }
+          }
+        }
+      }
+    }
+  } else {
+    const rList = p.r ?? [];
+    for (const r of rList) {
+      const textContent = extractTextContent(r);
+      const rPr = r.rPr;
+      const runProps = parseRunProperties(rPr, colorResolver, rels, fontScheme, mergedDefaults);
+      runs.push({ text: textContent, properties: runProps });
+    }
+    const fldList = p.fld ?? [];
+    for (const fld of fldList) {
+      const textContent = extractTextContent(fld);
+      const rPr = fld.rPr;
+      const runProps = parseRunProperties(rPr, colorResolver, rels, fontScheme, mergedDefaults);
+      runs.push({ text: textContent, properties: runProps });
+    }
+    const brList = p.br ?? [];
+    for (const _br of brList) {
+      const rPr = _br?.rPr;
+      const runProps = parseRunProperties(rPr, colorResolver, rels, fontScheme, mergedDefaults);
+      runs.push({ text: "\n", properties: runProps });
+    }
+    const mNode = p.m;
+    if (mNode) {
+      const mArr = Array.isArray(mNode) ? mNode : [mNode];
+      for (const m of mArr) {
+        const mathText = extractMathText(m);
+        if (mathText) {
+          const runProps = parseRunProperties(
+            void 0,
+            colorResolver,
+            rels,
+            fontScheme,
+            mergedDefaults
+          );
+          runs.push({ text: mathText, properties: runProps });
+        }
+      }
+    }
   }
   return { runs, properties };
 }
-function parseRunProperties(rPr, colorResolver) {
+function mergeDefaultRunProperties(primary, secondary) {
+  if (!primary && !secondary) return void 0;
+  if (!primary) return secondary;
+  if (!secondary) return primary;
+  return {
+    fontSize: primary.fontSize ?? secondary.fontSize,
+    fontFamily: primary.fontFamily ?? secondary.fontFamily,
+    fontFamilyEa: primary.fontFamilyEa ?? secondary.fontFamilyEa,
+    bold: primary.bold ?? secondary.bold,
+    italic: primary.italic ?? secondary.italic,
+    underline: primary.underline ?? secondary.underline,
+    strikethrough: primary.strikethrough ?? secondary.strikethrough
+  };
+}
+function parseRunProperties(rPr, colorResolver, rels, fontScheme, defaults) {
   if (!rPr) {
     return {
-      fontSize: null,
-      fontFamily: null,
-      fontFamilyEa: null,
-      bold: false,
-      italic: false,
-      underline: false,
-      strikethrough: false,
+      fontSize: defaults?.fontSize ?? null,
+      fontFamily: resolveThemeFont(defaults?.fontFamily ?? null, fontScheme),
+      fontFamilyEa: resolveThemeFont(defaults?.fontFamilyEa ?? null, fontScheme),
+      bold: defaults?.bold ?? false,
+      italic: defaults?.italic ?? false,
+      underline: defaults?.underline ?? false,
+      strikethrough: defaults?.strikethrough ?? false,
       color: null,
-      baseline: 0
+      baseline: 0,
+      hyperlink: null
     };
   }
-  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";
+  if (rPr.effectLst) {
+    warn("rPr.effectLst", "text run effects not implemented");
+  }
+  if (rPr.highlight) {
+    warn("rPr.highlight", "text highlighting not implemented");
+  }
+  const latin = rPr.latin;
+  const ea = rPr.ea;
+  const fontSize = rPr["@_sz"] ? hundredthPointToPoint(Number(rPr["@_sz"])) : defaults?.fontSize ?? null;
+  const fontFamily = resolveThemeFont(
+    latin?.["@_typeface"] ?? defaults?.fontFamily ?? null,
+    fontScheme
+  );
+  const fontFamilyEa = resolveThemeFont(
+    ea?.["@_typeface"] ?? defaults?.fontFamilyEa ?? null,
+    fontScheme
+  );
+  const bold = rPr["@_b"] !== void 0 ? rPr["@_b"] === "1" || rPr["@_b"] === "true" : defaults?.bold ?? false;
+  const italic = rPr["@_i"] !== void 0 ? rPr["@_i"] === "1" || rPr["@_i"] === "true" : defaults?.italic ?? false;
+  const underline = rPr["@_u"] !== void 0 ? rPr["@_u"] !== "none" : defaults?.underline ?? false;
+  const strikethrough = rPr["@_strike"] !== void 0 ? rPr["@_strike"] !== "noStrike" : defaults?.strikethrough ?? false;
   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) {
+  const solidFill = rPr.solidFill;
+  let color = colorResolver.resolve(solidFill ?? rPr);
+  if (!solidFill && !rPr.srgbClr && !rPr.schemeClr && !rPr.sysClr) {
     color = null;
   }
+  const hyperlink = parseHyperlink(rPr.hlinkClick, rels);
   return {
     fontSize,
     fontFamily,
@@ -993,12 +2049,21 @@ function parseRunProperties(rPr, colorResolver) {
     underline,
     strikethrough,
     color,
-    baseline
+    baseline,
+    hyperlink
   };
 }
+function parseHyperlink(hlinkClick, rels) {
+  if (!hlinkClick) return null;
+  const rId = hlinkClick["@_r:id"] ?? hlinkClick["@_id"];
+  if (!rId || !rels) return null;
+  const rel = rels.get(rId);
+  if (!rel) return null;
+  const tooltip = hlinkClick["@_tooltip"];
+  return { url: rel.target, ...tooltip && { tooltip } };
+}
 
 // src/parser/slide-master-parser.ts
-var WARN_PREFIX6 = "[pptx-glimpse]";
 var DEFAULT_COLOR_MAP = {
   bg1: "lt1",
   tx1: "dk1",
@@ -1015,11 +2080,12 @@ var DEFAULT_COLOR_MAP = {
 };
 function parseSlideMasterColorMap(xml) {
   const parsed = parseXml(xml);
-  if (!parsed.sldMaster) {
-    console.warn(`${WARN_PREFIX6} SlideMaster: missing root element "sldMaster" in XML`);
+  const sldMaster = parsed.sldMaster;
+  if (!sldMaster) {
+    debug("slideMaster.missing", `missing root element "sldMaster" in XML`);
     return { ...DEFAULT_COLOR_MAP };
   }
-  const clrMap = parsed.sldMaster.clrMap;
+  const clrMap = sldMaster.clrMap;
   if (!clrMap) return { ...DEFAULT_COLOR_MAP };
   const result = {};
   for (const key of Object.keys(DEFAULT_COLOR_MAP)) {
@@ -1030,74 +2096,192 @@ function parseSlideMasterColorMap(xml) {
 }
 function parseSlideMasterBackground(xml, colorResolver, context) {
   const parsed = parseXml(xml);
-  if (!parsed.sldMaster) {
-    console.warn(`${WARN_PREFIX6} SlideMaster: missing root element "sldMaster" in XML`);
+  const sldMaster = parsed.sldMaster;
+  if (!sldMaster) {
+    debug("slideMaster.missing", `missing root element "sldMaster" in XML`);
     return null;
   }
-  const bg = parsed.sldMaster.cSld?.bg;
+  const cSld = sldMaster.cSld;
+  const bg = 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) {
+function parseSlideMasterElements(xml, masterPath, archive, colorResolver, fontScheme) {
   const parsed = parseXml(xml);
-  if (!parsed.sldMaster) {
-    console.warn(`${WARN_PREFIX6} SlideMaster: missing root element "sldMaster" in XML`);
+  const sldMaster = parsed.sldMaster;
+  if (!sldMaster) {
+    debug("slideMaster.missing", `missing root element "sldMaster" in XML`);
     return [];
   }
-  const spTree = parsed.sldMaster.cSld?.spTree;
+  const cSld = sldMaster.cSld;
+  const spTree = 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);
+  const orderedParsed = parseXmlOrdered(xml);
+  const orderedSpTree = navigateOrdered(orderedParsed, ["sldMaster", "cSld", "spTree"]);
+  return parseShapeTree(
+    spTree,
+    rels,
+    masterPath,
+    archive,
+    colorResolver,
+    void 0,
+    void 0,
+    fontScheme,
+    orderedSpTree
+  );
+}
+function parseSlideMasterTxStyles(xml, colorResolver) {
+  const parsed = parseXml(xml);
+  const sldMaster = parsed.sldMaster;
+  if (!sldMaster) {
+    debug("slideMaster.missing", `missing root element "sldMaster" in XML`);
+    return void 0;
+  }
+  const txStyles = sldMaster.txStyles;
+  if (!txStyles) return void 0;
+  const titleStyleNode = txStyles.titleStyle;
+  const bodyStyleNode = txStyles.bodyStyle;
+  const otherStyleNode = txStyles.otherStyle;
+  const titleStyle = titleStyleNode ? parseListStyle(titleStyleNode, colorResolver) : void 0;
+  const bodyStyle = bodyStyleNode ? parseListStyle(bodyStyleNode, colorResolver) : void 0;
+  const otherStyle = otherStyleNode ? parseListStyle(otherStyleNode, colorResolver) : void 0;
+  if (!titleStyle && !bodyStyle && !otherStyle) return void 0;
+  return { titleStyle, bodyStyle, otherStyle };
+}
+function parseSlideMasterPlaceholderStyles(xml, colorResolver) {
+  const parsed = parseXml(xml);
+  const sldMaster = parsed.sldMaster;
+  if (!sldMaster) return [];
+  const cSld = sldMaster.cSld;
+  const spTree = cSld?.spTree;
+  if (!spTree) return [];
+  const results = [];
+  const shapes = spTree.sp ?? [];
+  for (const sp of shapes) {
+    const nvSpPr = sp.nvSpPr;
+    const nvPr = nvSpPr?.nvPr;
+    const ph = nvPr?.ph;
+    if (!ph) continue;
+    const placeholderType = ph["@_type"] ?? "body";
+    const placeholderIdx = ph["@_idx"] !== void 0 ? Number(ph["@_idx"]) : void 0;
+    const txBody = sp.txBody;
+    const lstStyleNode = txBody?.lstStyle;
+    const lstStyle = lstStyleNode ? parseListStyle(lstStyleNode, colorResolver) : void 0;
+    results.push({
+      placeholderType,
+      ...placeholderIdx !== void 0 && { placeholderIdx },
+      ...lstStyle && { lstStyle }
+    });
+  }
+  return results;
 }
 
 // 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`);
+  const sldLayout = parsed.sldLayout;
+  if (!sldLayout) {
+    debug("slideLayout.missing", `missing root element "sldLayout" in XML`);
     return null;
   }
-  const bg = parsed.sldLayout.cSld?.bg;
+  const cSld = sldLayout.cSld;
+  const bg = 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) {
+function parseSlideLayoutElements(xml, layoutPath, archive, colorResolver, fontScheme) {
   const parsed = parseXml(xml);
-  if (!parsed.sldLayout) {
-    console.warn(`${WARN_PREFIX7} SlideLayout: missing root element "sldLayout" in XML`);
+  const sldLayout = parsed.sldLayout;
+  if (!sldLayout) {
+    debug("slideLayout.missing", `missing root element "sldLayout" in XML`);
     return [];
   }
-  const spTree = parsed.sldLayout.cSld?.spTree;
+  const cSld = sldLayout.cSld;
+  const spTree = 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);
+  const orderedParsed = parseXmlOrdered(xml);
+  const orderedSpTree = navigateOrdered(orderedParsed, ["sldLayout", "cSld", "spTree"]);
+  return parseShapeTree(
+    spTree,
+    rels,
+    layoutPath,
+    archive,
+    colorResolver,
+    void 0,
+    void 0,
+    fontScheme,
+    orderedSpTree
+  );
+}
+function parseSlideLayoutShowMasterSp(xml) {
+  const parsed = parseXml(xml);
+  const sldLayout = parsed.sldLayout;
+  const attr = sldLayout?.["@_showMasterSp"];
+  return attr !== "0" && attr !== "false";
+}
+function parseSlideLayoutPlaceholderStyles(xml, colorResolver) {
+  const parsed = parseXml(xml);
+  const sldLayout = parsed.sldLayout;
+  if (!sldLayout) return [];
+  const cSld = sldLayout.cSld;
+  const spTree = cSld?.spTree;
+  if (!spTree) return [];
+  const results = [];
+  const shapes = spTree.sp ?? [];
+  for (const sp of shapes) {
+    const nvSpPr = sp.nvSpPr;
+    const nvPr = nvSpPr?.nvPr;
+    const ph = nvPr?.ph;
+    if (!ph) continue;
+    const placeholderType = ph["@_type"] ?? "body";
+    const placeholderIdx = ph["@_idx"] !== void 0 ? Number(ph["@_idx"]) : void 0;
+    const txBody = sp.txBody;
+    const lstStyleNode = txBody?.lstStyle;
+    const lstStyle = lstStyleNode ? parseListStyle(lstStyleNode, colorResolver) : void 0;
+    results.push({
+      placeholderType,
+      ...placeholderIdx !== void 0 && { placeholderIdx },
+      ...lstStyle && { lstStyle }
+    });
+  }
+  return results;
 }
 
 // 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"]);
+  const lumMod = node.lumMod;
+  const lumOff = node.lumOff;
+  if (lumMod || lumOff) {
+    hex = applyLuminance(
+      hex,
+      lumMod?.["@_val"],
+      lumOff?.["@_val"]
+    );
   }
-  if (node.tint) {
-    hex = applyTint(hex, Number(node.tint["@_val"]) / 1e5);
+  const tintNode = node.tint;
+  if (tintNode) {
+    hex = applyTint(hex, Number(tintNode["@_val"]) / 1e5);
   }
-  if (node.shade) {
-    hex = applyShade(hex, Number(node.shade["@_val"]) / 1e5);
+  const shadeNode = node.shade;
+  if (shadeNode) {
+    hex = applyShade(hex, Number(shadeNode["@_val"]) / 1e5);
   }
-  if (node.alpha) {
-    alpha = Number(node.alpha["@_val"]) / 1e5;
+  const alphaNode = node.alpha;
+  if (alphaNode) {
+    alpha = Number(alphaNode["@_val"]) / 1e5;
   }
   return { hex, alpha };
 }
@@ -1180,13 +2364,11 @@ function hslToHex(h, s, l) {
 }
 
 // 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) {
@@ -1200,26 +2382,21 @@ var ColorResolver = class {
     }
     const keys = Object.keys(colorNode).filter((k) => !k.startsWith("@_"));
     if (keys.length > 0) {
-      console.warn(
-        `${WARN_PREFIX8} ColorResolver: unknown color node structure [${keys.join(", ")}]`
-      );
+      debug("colorResolver.unknown", `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);
@@ -1338,6 +2515,42 @@ var presetGeometries = {
     return `<polygon points="${bodyLeft},0 ${bodyRight},0 ${bodyRight},${shaftEnd} ${w},${shaftEnd} ${w / 2},${h} 0,${shaftEnd} ${bodyLeft},${shaftEnd}"/>`;
   },
   line: () => "",
+  // =====================
+  // Connector shapes
+  // =====================
+  straightConnector1: (w, h) => `<path d="M 0 0 L ${w} ${h}"/>`,
+  bentConnector2: (w, h) => `<path d="M 0 0 L ${w} 0 L ${w} ${h}"/>`,
+  bentConnector3: (w, h, adj) => {
+    const midX = (adj["adj1"] ?? 5e4) / 1e5 * w;
+    return `<path d="M 0 0 L ${midX} 0 L ${midX} ${h} L ${w} ${h}"/>`;
+  },
+  bentConnector4: (w, h, adj) => {
+    const midX = (adj["adj1"] ?? 5e4) / 1e5 * w;
+    const midY = (adj["adj2"] ?? 5e4) / 1e5 * h;
+    return `<path d="M 0 0 L ${midX} 0 L ${midX} ${midY} L ${w} ${midY} L ${w} ${h}"/>`;
+  },
+  bentConnector5: (w, h, adj) => {
+    const midX1 = (adj["adj1"] ?? 5e4) / 1e5 * w;
+    const midY = (adj["adj2"] ?? 5e4) / 1e5 * h;
+    const midX2 = (adj["adj3"] ?? 5e4) / 1e5 * w;
+    return `<path d="M 0 0 L ${midX1} 0 L ${midX1} ${midY} L ${midX2} ${midY} L ${midX2} ${h} L ${w} ${h}"/>`;
+  },
+  curvedConnector2: (w, h) => `<path d="M 0 0 C ${w} 0 0 ${h} ${w} ${h}"/>`,
+  curvedConnector3: (w, h, adj) => {
+    const midX = (adj["adj1"] ?? 5e4) / 1e5 * w;
+    return `<path d="M 0 0 C ${midX} 0 ${midX} ${h} ${w} ${h}"/>`;
+  },
+  curvedConnector4: (w, h, adj) => {
+    const midX = (adj["adj1"] ?? 5e4) / 1e5 * w;
+    const midY = (adj["adj2"] ?? 5e4) / 1e5 * h;
+    return `<path d="M 0 0 C ${midX} 0 ${midX} ${midY} ${midX} ${midY} S ${w} ${midY} ${w} ${h}"/>`;
+  },
+  curvedConnector5: (w, h, adj) => {
+    const midX1 = (adj["adj1"] ?? 5e4) / 1e5 * w;
+    const midY = (adj["adj2"] ?? 5e4) / 1e5 * h;
+    const midX2 = (adj["adj3"] ?? 5e4) / 1e5 * w;
+    return `<path d="M 0 0 C ${midX1} 0 ${midX1} ${midY} ${midX1} ${midY} S ${midX2} ${midY} ${midX2} ${h} S ${w} ${h} ${w} ${h}"/>`;
+  },
   cloud: (w, h) => `<rect width="${w}" height="${h}" rx="${Math.min(w, h) * 0.15}"/>`,
   heart: (w, h) => {
     const cx = w / 2;
@@ -1402,7 +2615,7 @@ var presetGeometries = {
     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;
+    const offset = (adj["adj"] ?? 5e4) / 1e5 * Math.min(w, h);
     return `<polygon points="0,0 ${w - offset},0 ${w},${h / 2} ${w - offset},${h} 0,${h}"/>`;
   },
   leftRightUpArrow: (w, h, adj) => {
@@ -1993,11 +3206,27 @@ 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}"/>`;
+  if (geometry.type === "custom" && geometry.paths.length > 0) {
+    return renderCustomGeometry(geometry.paths, width, height);
   }
   return `<rect width="${width}" height="${height}"/>`;
 }
+function renderCustomGeometry(paths, shapeWidth, shapeHeight) {
+  if (paths.length === 1) {
+    return renderCustomPath(paths[0], shapeWidth, shapeHeight);
+  }
+  const parts = ["<g>"];
+  for (const path of paths) {
+    parts.push(renderCustomPath(path, shapeWidth, shapeHeight));
+  }
+  parts.push("</g>");
+  return parts.join("");
+}
+function renderCustomPath(path, shapeWidth, shapeHeight) {
+  const scaleX = path.width > 0 ? shapeWidth / path.width : 1;
+  const scaleY = path.height > 0 ? shapeHeight / path.height : 1;
+  return `<path d="${path.commands}" transform="scale(${scaleX}, ${scaleY})"/>`;
+}
 
 // src/renderer/fill-renderer.ts
 function renderFillAttrs(fill) {
@@ -2009,41 +3238,78 @@ function renderFillAttrs(fill) {
     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>`;
+    const result = renderGradientDefs(fill);
+    return { attrs: `fill="${result.ref}"`, defs: result.defs };
+  }
+  if (fill.type === "image") {
+    const id = `imgfill-${crypto.randomUUID()}`;
+    const defs = `<pattern id="${id}" patternContentUnits="objectBoundingBox" width="1" height="1"><image href="data:${fill.mimeType};base64,${fill.imageData}" width="1" height="1" preserveAspectRatio="none"/></pattern>`;
     return { attrs: `fill="url(#${id})"`, defs };
   }
+  if (fill.type === "pattern") {
+    return renderPatternFill(fill);
+  }
   return { attrs: `fill="none"`, defs: "" };
 }
 function renderOutlineAttrs(outline) {
-  if (!outline) return `stroke="none"`;
+  if (!outline) return { attrs: `stroke="none"`, defs: "" };
   const widthPx = emuToPixels(outline.width);
   const parts = [`stroke-width="${widthPx}"`];
+  let defs = "";
   if (outline.fill) {
-    parts.push(`stroke="${outline.fill.color.hex}"`);
-    if (outline.fill.color.alpha < 1) {
-      parts.push(`stroke-opacity="${outline.fill.color.alpha}"`);
+    if (outline.fill.type === "solid") {
+      parts.push(`stroke="${outline.fill.color.hex}"`);
+      if (outline.fill.color.alpha < 1) {
+        parts.push(`stroke-opacity="${outline.fill.color.alpha}"`);
+      }
+    } else if (outline.fill.type === "gradient") {
+      const gradResult = renderGradientDefs(outline.fill);
+      parts.push(`stroke="${gradResult.ref}"`);
+      defs = gradResult.defs;
     }
   } else {
     parts.push(`stroke="none"`);
   }
-  if (outline.dashStyle !== "solid") {
+  if (outline.customDash && outline.customDash.length > 0) {
+    const dashArray = outline.customDash.map((v) => v * widthPx).join(" ");
+    parts.push(`stroke-dasharray="${dashArray}"`);
+  } else if (outline.dashStyle !== "solid") {
     const dashArray = getDashArray(outline.dashStyle, widthPx);
     if (dashArray) {
       parts.push(`stroke-dasharray="${dashArray}"`);
     }
   }
-  return parts.join(" ");
+  if (outline.lineCap) {
+    parts.push(`stroke-linecap="${outline.lineCap}"`);
+  }
+  if (outline.lineJoin) {
+    parts.push(`stroke-linejoin="${outline.lineJoin}"`);
+  }
+  return { attrs: parts.join(" "), defs };
+}
+function renderGradientDefs(fill) {
+  const id = `grad-${crypto.randomUUID()}`;
+  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("");
+  if (fill.gradientType === "radial") {
+    const cx = (fill.centerX ?? 0.5) * 100;
+    const cy = (fill.centerY ?? 0.5) * 100;
+    const dx = Math.max(cx, 100 - cx);
+    const dy = Math.max(cy, 100 - cy);
+    const r = Math.sqrt(dx * dx + dy * dy);
+    const defs2 = `<radialGradient id="${id}" cx="${cx}%" cy="${cy}%" r="${r}%">${stops}</radialGradient>`;
+    return { ref: `url(#${id})`, defs: defs2 };
+  }
+  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 defs = `<linearGradient id="${id}" x1="${x1}%" y1="${y1}%" x2="${x2}%" y2="${y2}%">${stops}</linearGradient>`;
+  return { ref: `url(#${id})`, defs };
 }
 function getDashArray(style, w) {
   const patterns = {
@@ -2059,6 +3325,185 @@ function getDashArray(style, w) {
   if (!pattern) return null;
   return pattern.map((v) => v * w).join(" ");
 }
+function renderPatternFill(fill) {
+  const id = `patt-${crypto.randomUUID()}`;
+  const fg = fill.foregroundColor.hex;
+  const bg = fill.backgroundColor.hex;
+  const fgAlpha = fill.foregroundColor.alpha < 1 ? ` opacity="${fill.foregroundColor.alpha}"` : "";
+  const content = getPatternContent(fill.preset, fg, fgAlpha);
+  if (!content) {
+    const alphaAttr = fill.foregroundColor.alpha < 1 ? ` fill-opacity="${fill.foregroundColor.alpha}"` : "";
+    return { attrs: `fill="${fg}"${alphaAttr}`, defs: "" };
+  }
+  const bgAlpha = fill.backgroundColor.alpha < 1 ? ` fill-opacity="${fill.backgroundColor.alpha}"` : "";
+  const defs = `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${content.size}" height="${content.size}"><rect width="${content.size}" height="${content.size}" fill="${bg}"${bgAlpha}/>${content.svg}</pattern>`;
+  return { attrs: `fill="url(#${id})"`, defs };
+}
+function getPatternContent(preset, fg, fgAlpha) {
+  const s = 8;
+  const sw = 1;
+  const line = (x1, y1, x2, y2) => `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${fg}" stroke-width="${sw}"${fgAlpha}/>`;
+  switch (preset) {
+    case "ltHorz":
+      return { svg: line(0, 4, 8, 4), size: s };
+    case "ltVert":
+      return { svg: line(4, 0, 4, 8), size: s };
+    case "ltDnDiag":
+      return { svg: line(0, 0, 8, 8), size: s };
+    case "ltUpDiag":
+      return { svg: line(0, 8, 8, 0), size: s };
+    case "dkHorz":
+      return {
+        svg: line(0, 2, 8, 2) + line(0, 6, 8, 6),
+        size: s
+      };
+    case "dkVert":
+      return {
+        svg: line(2, 0, 2, 8) + line(6, 0, 6, 8),
+        size: s
+      };
+    case "dkDnDiag":
+      return {
+        svg: line(0, 0, 8, 8) + line(-4, 0, 4, 8),
+        size: s
+      };
+    case "dkUpDiag":
+      return {
+        svg: line(0, 8, 8, 0) + line(4, 8, 12, 0),
+        size: s
+      };
+    case "horz":
+      return { svg: line(0, 4, 8, 4), size: s };
+    case "vert":
+      return { svg: line(4, 0, 4, 8), size: s };
+    case "dnDiag":
+      return { svg: line(0, 0, 8, 8), size: s };
+    case "upDiag":
+      return { svg: line(0, 8, 8, 0), size: s };
+    case "cross":
+    case "smGrid":
+      return {
+        svg: line(0, 4, 8, 4) + line(4, 0, 4, 8),
+        size: s
+      };
+    case "lgGrid":
+      return {
+        svg: line(0, 0, 16, 0) + line(0, 0, 0, 16),
+        size: 16
+      };
+    case "diagCross":
+      return {
+        svg: line(0, 0, 8, 8) + line(0, 8, 8, 0),
+        size: s
+      };
+    case "pct5":
+      return {
+        svg: `<rect x="0" y="0" width="1" height="1" fill="${fg}"${fgAlpha}/>`,
+        size: s
+      };
+    case "pct10":
+      return {
+        svg: `<rect x="0" y="0" width="1" height="1" fill="${fg}"${fgAlpha}/><rect x="4" y="4" width="1" height="1" fill="${fg}"${fgAlpha}/>`,
+        size: s
+      };
+    case "pct20":
+      return {
+        svg: `<rect x="0" y="0" width="2" height="2" fill="${fg}"${fgAlpha}/><rect x="4" y="4" width="2" height="2" fill="${fg}"${fgAlpha}/>`,
+        size: s
+      };
+    case "pct25":
+      return {
+        svg: `<rect x="0" y="0" width="2" height="2" fill="${fg}"${fgAlpha}/><rect x="4" y="0" width="2" height="2" fill="${fg}"${fgAlpha}/><rect x="2" y="4" width="2" height="2" fill="${fg}"${fgAlpha}/><rect x="6" y="4" width="2" height="2" fill="${fg}"${fgAlpha}/>`,
+        size: s
+      };
+    case "pct30":
+    case "pct40":
+    case "pct50":
+    case "pct60":
+    case "pct70":
+    case "pct75":
+    case "pct80":
+    case "pct90": {
+      const pctVal = parseInt(preset.replace("pct", ""), 10);
+      const alpha = pctVal / 100;
+      return {
+        svg: `<rect width="${s}" height="${s}" fill="${fg}" opacity="${alpha}"${fgAlpha}/>`,
+        size: s
+      };
+    }
+    default:
+      return null;
+  }
+}
+var ARROW_SIZE_MAP = {
+  sm: 5,
+  med: 8,
+  lg: 12
+};
+function renderMarkers(outline) {
+  const empty = { defs: "", startAttr: "", endAttr: "" };
+  if (!outline) return empty;
+  if (!outline.headEnd && !outline.tailEnd) return empty;
+  let color = "#000000";
+  let alpha = 1;
+  if (outline.fill?.type === "solid") {
+    color = outline.fill.color.hex;
+    alpha = outline.fill.color.alpha;
+  } else if (outline.fill?.type === "gradient" && outline.fill.stops.length > 0) {
+    color = outline.fill.stops[0].color.hex;
+    alpha = outline.fill.stops[0].color.alpha;
+  }
+  const defs = [];
+  let startAttr = "";
+  let endAttr = "";
+  if (outline.headEnd) {
+    const id = `marker-${crypto.randomUUID()}`;
+    const markerDef = buildMarkerDef(id, outline.headEnd, color, alpha);
+    if (markerDef) {
+      defs.push(markerDef);
+      startAttr = `marker-start="url(#${id})"`;
+    }
+  }
+  if (outline.tailEnd) {
+    const id = `marker-${crypto.randomUUID()}`;
+    const markerDef = buildMarkerDef(id, outline.tailEnd, color, alpha);
+    if (markerDef) {
+      defs.push(markerDef);
+      endAttr = `marker-end="url(#${id})"`;
+    }
+  }
+  return { defs: defs.join(""), startAttr, endAttr };
+}
+function buildMarkerDef(id, endpoint, color, alpha) {
+  const mw = ARROW_SIZE_MAP[endpoint.length];
+  const mh = ARROW_SIZE_MAP[endpoint.width];
+  const alphaAttr = alpha < 1 ? ` opacity="${alpha}"` : "";
+  let path;
+  let fillAttr2;
+  switch (endpoint.type) {
+    case "triangle":
+      path = `M 0 0 L ${mw} ${mh / 2} L 0 ${mh} Z`;
+      fillAttr2 = `fill="${color}"`;
+      break;
+    case "stealth":
+      path = `M 0 0 L ${mw} ${mh / 2} L 0 ${mh} L ${mw * 0.3} ${mh / 2} Z`;
+      fillAttr2 = `fill="${color}"`;
+      break;
+    case "diamond":
+      path = `M 0 ${mh / 2} L ${mw / 2} 0 L ${mw} ${mh / 2} L ${mw / 2} ${mh} Z`;
+      fillAttr2 = `fill="${color}"`;
+      break;
+    case "oval":
+      return `<marker id="${id}" markerWidth="${mw}" markerHeight="${mh}" refX="${mw / 2}" refY="${mh / 2}" orient="auto" markerUnits="userSpaceOnUse"><ellipse cx="${mw / 2}" cy="${mh / 2}" rx="${mw / 2}" ry="${mh / 2}" ${`fill="${color}"`}${alphaAttr}/></marker>`;
+    case "arrow":
+      path = `M 0 0 L ${mw} ${mh / 2} L 0 ${mh}`;
+      fillAttr2 = `fill="none" stroke="${color}" stroke-width="1"`;
+      break;
+    default:
+      return null;
+  }
+  return `<marker id="${id}" markerWidth="${mw}" markerHeight="${mh}" refX="${mw}" refY="${mh / 2}" orient="auto" markerUnits="userSpaceOnUse"><path d="${path}" ${fillAttr2}${alphaAttr}/></marker>`;
+}
 
 // src/data/font-metrics.ts
 var metricsData = {
@@ -2912,8 +4357,11 @@ function getMetricsFallbackFont(fontFamily) {
 // src/utils/text-measure.ts
 var WIDTH_RATIO = {
   narrow: 0.3,
+  // i, l, 1, 句読点等
   normal: 0.6,
+  // ラテン文字の平均的な幅
   wide: 1
+  // CJK 文字 (全角)
 };
 var BOLD_FACTOR = 1.05;
 var PX_PER_PT = 96 / 72;
@@ -2924,7 +4372,10 @@ function getLineHeightRatio(fontFamily, fontFamilyEa) {
   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;
+  return codePoint >= 12288 && codePoint <= 40959 || // CJK 記号・ひらがな・カタカナ・統合漢字
+  codePoint >= 63744 && codePoint <= 64255 || // CJK 互換漢字
+  codePoint >= 65281 && codePoint <= 65376 || // 全角英数・記号
+  codePoint >= 131072 && codePoint <= 173791;
 }
 function categorizeChar(codePoint) {
   if (isCjkCodePoint(codePoint)) {
@@ -2988,6 +4439,7 @@ function measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa) {
 
 // src/utils/text-wrap.ts
 var DEFAULT_FONT_SIZE = 18;
+var WRAP_TOLERANCE_RATIO = 0.02;
 function isCjk(codePoint) {
   return codePoint >= 12288 && codePoint <= 40959 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 131072 && codePoint <= 173791;
 }
@@ -3040,6 +4492,39 @@ function tokenizeRuns(runs, defaultFontSize, fontScale) {
   let isFirst = true;
   for (const run of runs) {
     if (run.text.length === 0) continue;
+    if (run.text.includes("\n")) {
+      const parts = run.text.split("\n");
+      for (let pi = 0; pi < parts.length; pi++) {
+        if (pi > 0) {
+          tokens.push({
+            text: "",
+            properties: run.properties,
+            width: 0,
+            breakable: true,
+            forceBreak: true
+          });
+          isFirst = false;
+        }
+        const part = parts[pi];
+        if (part.length === 0) continue;
+        const fontSize2 = run.properties.fontSize ? run.properties.fontSize * fontScale : defaultFontSize;
+        const bold2 = run.properties.bold;
+        const fontFamily2 = run.properties.fontFamily;
+        const fontFamilyEa2 = run.properties.fontFamilyEa;
+        const fragments2 = splitTextIntoFragments(part);
+        for (const { fragment, breakable } of fragments2) {
+          const width = measureTextWidth(fragment, fontSize2, bold2, fontFamily2, fontFamilyEa2);
+          tokens.push({
+            text: fragment,
+            properties: run.properties,
+            width,
+            breakable: isFirst ? false : breakable
+          });
+          isFirst = false;
+        }
+      }
+      continue;
+    }
     const fontSize = run.properties.fontSize ? run.properties.fontSize * fontScale : defaultFontSize;
     const bold = run.properties.bold;
     const fontFamily = run.properties.fontFamily;
@@ -3124,9 +4609,17 @@ function layoutTokensIntoLines(tokens, availableWidth, defaultFontSize, fontScal
   const lines = [];
   let currentLine = [];
   let currentWidth = 0;
+  const tolerance = availableWidth * WRAP_TOLERANCE_RATIO;
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i];
-    if (currentWidth + token.width <= availableWidth) {
+    if (token.forceBreak) {
+      const segments = trimTrailingSpaces(mergeSegments(currentLine));
+      lines.push({ segments: segments.length > 0 ? segments : [] });
+      currentLine = [];
+      currentWidth = 0;
+      continue;
+    }
+    if (currentWidth + token.width <= availableWidth + tolerance) {
       currentLine.push(token);
       currentWidth += token.width;
     } else if (currentLine.length === 0) {
@@ -3190,17 +4683,31 @@ function renderTextBody(textBody, transform) {
   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 fullTextWidth = width - marginLeft - marginRight;
+  const numCol = bodyProperties.numCol ?? 1;
+  const textWidth = numCol > 1 ? fullTextWidth / numCol : fullTextWidth;
   const defaultFontSize = getDefaultFontSize(paragraphs);
   const shouldWrap = bodyProperties.wrap !== "none";
-  const fontScale = bodyProperties.fontScale;
+  let fontScale = bodyProperties.fontScale;
   const lnSpcReduction = bodyProperties.lnSpcReduction;
+  if (bodyProperties.autoFit === "normAutofit" && shouldWrap) {
+    const availableHeight = height - marginTop - marginBottom;
+    fontScale = computeShrinkToFitScale(
+      paragraphs,
+      defaultFontSize,
+      fontScale,
+      lnSpcReduction,
+      textWidth,
+      availableHeight
+    );
+  }
   const scaledDefaultFontSize = defaultFontSize * fontScale;
   const defaultLineHeightRatio = getDefaultLineHeightRatio(paragraphs);
   const defaultNaturalHeight = scaledDefaultFontSize * defaultLineHeightRatio;
   const tspans = [];
   let isFirstLine = true;
   const autoNumCounters = /* @__PURE__ */ new Map();
+  let prevSpaceAfterPx = 0;
   for (const para of paragraphs) {
     const paraMarginLeft = emuToPixels(para.properties.marginLeft);
     const paraIndent = emuToPixels(para.properties.indent);
@@ -3215,10 +4722,14 @@ function renderTextBody(textBody, transform) {
       width,
       marginRight
     );
+    const paraFontSize = getParagraphFontSize(para, defaultFontSize) * fontScale;
+    const spaceBeforePx = resolveSpacingPx(para.properties.spaceBefore, paraFontSize);
+    const paragraphGap = Math.max(prevSpaceAfterPx, spaceBeforePx);
     if (para.runs.length === 0 || !para.runs.some((r) => r.text.length > 0)) {
-      const dy = computeDy(isFirstLine, defaultNaturalHeight, DEFAULT_LINE_SPACING, para, true);
+      const dy = computeDy(isFirstLine, defaultNaturalHeight, DEFAULT_LINE_SPACING, paragraphGap);
       tspans.push(`<tspan x="${xPos}" dy="${dy}" text-anchor="${anchorValue}"> </tspan>`);
       isFirstLine = false;
+      prevSpaceAfterPx = resolveSpacingPx(para.properties.spaceAfter, paraFontSize);
       continue;
     }
     if (shouldWrap) {
@@ -3230,13 +4741,13 @@ function renderTextBody(textBody, transform) {
       );
       for (let lineIdx = 0; lineIdx < wrappedLines.length; lineIdx++) {
         const line = wrappedLines[lineIdx];
+        const lineGap = lineIdx === 0 ? paragraphGap : 0;
         if (line.segments.length === 0) {
           const dy = computeDy(
             isFirstLine,
             defaultNaturalHeight,
             getLineSpacing(para, lnSpcReduction),
-            para,
-            lineIdx === 0
+            lineGap
           );
           tspans.push(`<tspan x="${xPos}" dy="${dy}" text-anchor="${anchorValue}"> </tspan>`);
           isFirstLine = false;
@@ -3253,8 +4764,7 @@ function renderTextBody(textBody, transform) {
             isFirstLine,
             lineNaturalHeight,
             getLineSpacing(para, lnSpcReduction),
-            para,
-            true
+            paragraphGap
           );
           const bulletStyles = buildBulletStyleAttrs(para.properties, lineFontSize, fontScale);
           tspans.push(
@@ -3278,8 +4788,7 @@ function renderTextBody(textBody, transform) {
                 isFirstLine,
                 lineNaturalHeight,
                 getLineSpacing(para, lnSpcReduction),
-                para,
-                lineIdx === 0
+                lineGap
               );
               const prefix = `x="${xPos}" dy="${dy}" text-anchor="${anchorValue}" `;
               tspans.push(renderSegment(seg.text, seg.properties, fontScale, prefix));
@@ -3300,8 +4809,7 @@ function renderTextBody(textBody, transform) {
           isFirstLine,
           naturalHeight,
           getLineSpacing(para, lnSpcReduction),
-          para,
-          true
+          paragraphGap
         );
         const bulletStyles = buildBulletStyleAttrs(para.properties, fontSize, fontScale);
         tspans.push(
@@ -3321,8 +4829,7 @@ function renderTextBody(textBody, transform) {
               isFirstLine,
               naturalHeight,
               getLineSpacing(para, lnSpcReduction),
-              para,
-              true
+              paragraphGap
             );
             const prefix = `x="${xPos}" dy="${dy}" text-anchor="${anchorValue}" `;
             tspans.push(renderSegment(run.text, run.properties, fontScale, prefix));
@@ -3334,6 +4841,7 @@ function renderTextBody(textBody, transform) {
       }
       isFirstLine = false;
     }
+    prevSpaceAfterPx = resolveSpacingPx(para.properties.spaceAfter, paraFontSize);
   }
   let yStart = marginTop;
   const totalTextHeight = estimateTextHeight(
@@ -3467,13 +4975,24 @@ function getLineSpacing(para, lnSpcReduction = 0) {
   }
   return spacing * (1 - lnSpcReduction);
 }
-function computeDy(isFirstLine, fontSizePt, lineSpacingFactor, para, isFirstLineOfParagraph) {
+function resolveSpacingPx(spacing, fontSizePt) {
+  if (spacing.type === "pts") {
+    return spacing.value / 100 * PX_PER_PT2;
+  }
+  return fontSizePt * (spacing.value / 1e5) * PX_PER_PT2;
+}
+function getParagraphFontSize(para, defaultFontSize) {
+  for (const run of para.runs) {
+    if (run.text.length > 0 && run.properties.fontSize) {
+      return run.properties.fontSize;
+    }
+  }
+  return defaultFontSize;
+}
+function computeDy(isFirstLine, fontSizePt, lineSpacingFactor, paragraphGap) {
   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;
-  }
+  const dy = lineHeight + paragraphGap;
   return dy.toFixed(2);
 }
 function getLineFontSize(segments, defaultFontSize) {
@@ -3586,23 +5105,30 @@ function buildStyleAttrs(props, fontScale = 1, fontFamilies) {
   return styles.join(" ");
 }
 function renderSegment(text, props, fontScale, prefix) {
+  let tspanContent;
   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>`);
+    tspanContent = `<tspan ${prefix}${styles}>${escapeXml(text)}</tspan>`;
+  } else {
+    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>`);
+      }
     }
+    tspanContent = result.join("");
   }
-  return result.join("");
+  if (props.hyperlink) {
+    const href = escapeXml(props.hyperlink.url);
+    return `<a href="${href}">${tspanContent}</a>`;
+  }
+  return tspanContent;
 }
 function getDefaultFontSize(paragraphs) {
   for (const p of paragraphs) {
@@ -3622,9 +5148,53 @@ function getDefaultLineHeightRatio(paragraphs) {
   }
   return 1.2;
 }
+function computeSpAutofitHeight(textBody, transform) {
+  const { bodyProperties, paragraphs } = textBody;
+  const hasText = paragraphs.some((p) => p.runs.some((r) => r.text.length > 0));
+  if (!hasText) return null;
+  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 fullTextWidth = width - marginLeft - marginRight;
+  const numCol = bodyProperties.numCol ?? 1;
+  const textWidth = numCol > 1 ? fullTextWidth / numCol : fullTextWidth;
+  const defaultFontSize = getDefaultFontSize(paragraphs);
+  const shouldWrap = bodyProperties.wrap !== "none";
+  const textHeight = estimateTextHeight(paragraphs, defaultFontSize, shouldWrap, textWidth);
+  const requiredHeightPx = textHeight + marginTop + marginBottom;
+  if (requiredHeightPx <= height) return null;
+  const DEFAULT_DPI2 = 96;
+  return requiredHeightPx / DEFAULT_DPI2 * EMU_PER_INCH;
+}
+function computeShrinkToFitScale(paragraphs, defaultFontSize, fontScale, lnSpcReduction, textWidth, availableHeight) {
+  if (availableHeight <= 0) return fontScale;
+  const minScale = fontScale * 0.1;
+  let scale = fontScale;
+  const maxIterations = 5;
+  for (let i = 0; i < maxIterations; i++) {
+    const scaledDefault = defaultFontSize * scale;
+    const textHeight = estimateTextHeight(
+      paragraphs,
+      scaledDefault,
+      true,
+      textWidth,
+      lnSpcReduction,
+      scale
+    );
+    if (textHeight <= availableHeight) break;
+    const newScale = scale * (availableHeight / textHeight);
+    scale = Math.max(newScale, minScale);
+    if (scale <= minScale) break;
+  }
+  return scale;
+}
 function estimateTextHeight(paragraphs, defaultFontSize, shouldWrap, textWidth, lnSpcReduction = 0, fontScale = 1) {
   let totalHeight = 0;
   const defaultRatio = getDefaultLineHeightRatio(paragraphs);
+  let prevSpaceAfterPx = 0;
   for (let pIdx = 0; pIdx < paragraphs.length; pIdx++) {
     const para = paragraphs[pIdx];
     const lineSpacing = getLineSpacing(para, lnSpcReduction);
@@ -3638,14 +5208,19 @@ function estimateTextHeight(paragraphs, defaultFontSize, shouldWrap, textWidth,
       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;
+    if (pIdx > 0) {
+      const paraFontSize = getParagraphFontSize(para, defaultFontSize) * fontScale;
+      const spaceBeforePx = resolveSpacingPx(para.properties.spaceBefore, paraFontSize);
+      totalHeight += Math.max(prevSpaceAfterPx, spaceBeforePx);
     }
+    const paraFontSizeForAfter = getParagraphFontSize(para, defaultFontSize) * fontScale;
+    prevSpaceAfterPx = resolveSpacingPx(para.properties.spaceAfter, paraFontSizeForAfter);
   }
   return totalHeight;
 }
+var TAB_SPACES = "    ";
 function escapeXml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  return str.replace(/\t/g, TAB_SPACES).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 
 // src/renderer/effect-renderer.ts
@@ -3766,28 +5341,41 @@ function buildTransformAttr(t) {
 // 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);
+  let effectiveTransform = transform;
+  if (textBody?.bodyProperties.autoFit === "spAutofit") {
+    const requiredHeightEmu = computeSpAutofitHeight(textBody, transform);
+    if (requiredHeightEmu !== null) {
+      effectiveTransform = { ...transform, extentHeight: requiredHeightEmu };
+    }
+  }
+  const w = emuToPixels(effectiveTransform.extentWidth);
+  const h = emuToPixels(effectiveTransform.extentHeight);
+  const transformAttr = buildTransformAttr(effectiveTransform);
   const fillResult = renderFillAttrs(fill);
-  const outlineAttr = renderOutlineAttrs(outline);
+  const outlineResult = renderOutlineAttrs(outline);
   const effectResult = renderEffects(effects);
   const geometrySvg = renderGeometry(geometry, w, h);
   const parts = [];
   if (fillResult.defs) {
     parts.push(fillResult.defs);
   }
+  if (outlineResult.defs) {
+    parts.push(outlineResult.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}`);
+    const styledGeometry = geometrySvg.replace(
+      /^<(\w+)/,
+      `<$1 ${fillResult.attrs} ${outlineResult.attrs}`
+    );
     parts.push(styledGeometry);
   }
   if (textBody) {
-    const textSvg = renderTextBody(textBody, transform);
+    const textSvg = renderTextBody(textBody, effectiveTransform);
     if (textSvg) {
       parts.push(textSvg);
     }
@@ -3796,20 +5384,32 @@ function renderShape(shape) {
   return parts.join("");
 }
 function renderConnector(connector) {
-  const { transform, outline, effects } = connector;
+  const { transform, geometry, outline, effects } = connector;
   const w = emuToPixels(transform.extentWidth);
   const h = emuToPixels(transform.extentHeight);
   const transformAttr = buildTransformAttr(transform);
-  const outlineAttr = renderOutlineAttrs(outline);
+  const outlineResult = renderOutlineAttrs(outline);
   const effectResult = renderEffects(effects);
+  const markerResult = renderMarkers(outline);
   const parts = [];
-  if (effectResult.filterDefs) {
-    parts.push(effectResult.filterDefs);
-  }
+  if (outlineResult.defs) parts.push(outlineResult.defs);
+  if (markerResult.defs) parts.push(markerResult.defs);
+  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>`
-  );
+  const markerAttrs = [markerResult.startAttr, markerResult.endAttr].filter(Boolean).join(" ");
+  const markerAttrStr = markerAttrs ? ` ${markerAttrs}` : "";
+  const geometrySvg = renderGeometry(geometry, w, h);
+  parts.push(`<g transform="${transformAttr}"${filterAttr}>`);
+  if (geometrySvg) {
+    parts.push(
+      geometrySvg.replace(/^<(\w+)/, `<$1 ${outlineResult.attrs} fill="none"${markerAttrStr}`)
+    );
+  } else {
+    parts.push(
+      `<line x1="0" y1="0" x2="${w}" y2="${h}" ${outlineResult.attrs} fill="none"${markerAttrStr}/>`
+    );
+  }
+  parts.push("</g>");
   return parts.join("");
 }
 
@@ -3824,9 +5424,24 @@ function renderImage(image) {
     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>`
-  );
+  const src = image.srcRect;
+  if (src) {
+    const clipId = `crop-${crypto.randomUUID()}`;
+    const scaledW = Math.round(w / (1 - src.left - src.right));
+    const scaledH = Math.round(h / (1 - src.top - src.bottom));
+    const imgX = Math.round(-src.left * scaledW);
+    const imgY = Math.round(-src.top * scaledH);
+    parts.push(
+      `<defs><clipPath id="${clipId}"><rect x="0" y="0" width="${w}" height="${h}"/></clipPath></defs>`
+    );
+    parts.push(
+      `<g transform="${transformAttr}"${filterAttr}><image clip-path="url(#${clipId})" href="data:${image.mimeType};base64,${image.imageData}" x="${imgX}" y="${imgY}" width="${scaledW}" height="${scaledH}" preserveAspectRatio="none"/></g>`
+    );
+  } else {
+    parts.push(
+      `<g transform="${transformAttr}"${filterAttr}><image href="data:${image.mimeType};base64,${image.imageData}" width="${w}" height="${h}" preserveAspectRatio="none"/></g>`
+    );
+  }
   return parts.join("");
 }
 
@@ -3873,9 +5488,21 @@ function renderChart(element) {
       case "pie":
         parts.push(renderPieChart(chart, plotX, plotY, plotW, plotH));
         break;
+      case "doughnut":
+        parts.push(renderDoughnutChart(chart, plotX, plotY, plotW, plotH));
+        break;
       case "scatter":
         parts.push(renderScatterChart(chart, plotX, plotY, plotW, plotH));
         break;
+      case "bubble":
+        parts.push(renderBubbleChart(chart, plotX, plotY, plotW, plotH));
+        break;
+      case "area":
+        parts.push(renderAreaChart(chart, plotX, plotY, plotW, plotH));
+        break;
+      case "radar":
+        parts.push(renderRadarChart(chart, plotX, plotY, plotW, plotH));
+        break;
     }
   }
   if (chart.legend && chart.series.length > 0) {
@@ -3991,6 +5618,47 @@ function renderLineChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
+function renderAreaChart(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>`
+    );
+  }
+  const baseline = round2(y + h);
+  for (let s = 0; s < series.length; s++) {
+    const color = series[s].color;
+    const divisor = catCount > 1 ? catCount - 1 : 1;
+    const dataPoints = series[s].values.map((val, i) => {
+      const px = round2(x + i / divisor * w);
+      const py = round2(y + h - val / maxVal * h);
+      return { px, py };
+    });
+    const topPoints = dataPoints.map((p) => `${p.px},${p.py}`).join(" ");
+    const lastX = dataPoints[dataPoints.length - 1].px;
+    const firstX = dataPoints[0].px;
+    const polygonPoints = `${topPoints} ${lastX},${baseline} ${firstX},${baseline}`;
+    parts.push(
+      `<polygon points="${polygonPoints}" fill="${color.hex}" fill-opacity="${color.alpha < 1 ? color.alpha : 0.5}" stroke="${color.hex}" stroke-width="2"${color.alpha < 1 ? ` stroke-opacity="${color.alpha}"` : ""}/>`
+    );
+  }
+  return parts.join("");
+}
 function renderPieChart(chart, x, y, w, h) {
   const parts = [];
   const series = chart.series[0];
@@ -4023,6 +5691,47 @@ function renderPieChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
+function renderDoughnutChart(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 outerR = Math.min(w, h) / 2 * 0.85;
+  const holeSize = chart.holeSize ?? 50;
+  const innerR = outerR * (holeSize / 100);
+  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(outerR)}" ${fillAttr(color)}/>`
+      );
+      parts.push(
+        `<circle cx="${round2(cx)}" cy="${round2(cy)}" r="${round2(innerR)}" fill="#FFFFFF"/>`
+      );
+    } else {
+      const ox1 = cx + outerR * Math.cos(currentAngle);
+      const oy1 = cy + outerR * Math.sin(currentAngle);
+      const ox2 = cx + outerR * Math.cos(currentAngle + sliceAngle);
+      const oy2 = cy + outerR * Math.sin(currentAngle + sliceAngle);
+      const ix1 = cx + innerR * Math.cos(currentAngle + sliceAngle);
+      const iy1 = cy + innerR * Math.sin(currentAngle + sliceAngle);
+      const ix2 = cx + innerR * Math.cos(currentAngle);
+      const iy2 = cy + innerR * Math.sin(currentAngle);
+      const largeArc = sliceAngle > Math.PI ? 1 : 0;
+      parts.push(
+        `<path d="M${round2(ox1)},${round2(oy1)} A${round2(outerR)},${round2(outerR)} 0 ${largeArc},1 ${round2(ox2)},${round2(oy2)} L${round2(ix1)},${round2(iy1)} A${round2(innerR)},${round2(innerR)} 0 ${largeArc},0 ${round2(ix2)},${round2(iy2)} Z" ${fillAttr(color)}/>`
+      );
+    }
+    currentAngle += sliceAngle;
+  }
+  return parts.join("");
+}
 function renderScatterChart(chart, x, y, w, h) {
   const parts = [];
   const { series } = chart;
@@ -4055,27 +5764,137 @@ function renderScatterChart(chart, x, y, w, h) {
   }
   return parts.join("");
 }
+function renderBubbleChart(chart, x, y, w, h) {
+  const parts = [];
+  const { series } = chart;
+  if (series.length === 0) return "";
+  let maxX = 0;
+  let maxY = 0;
+  let maxBubble = 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);
+    const sizes = s.bubbleSizes ?? [];
+    for (const v of sizes) maxBubble = Math.max(maxBubble, v);
+  }
+  if (maxX === 0) maxX = 1;
+  if (maxY === 0) maxY = 1;
+  if (maxBubble === 0) maxBubble = 1;
+  const maxRadius = Math.min(w, h) * 0.08;
+  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 ?? [];
+    const sizes = series[s].bubbleSizes ?? [];
+    for (let i = 0; i < series[s].values.length; i++) {
+      const xVal = xVals[i] ?? i;
+      const yVal = series[s].values[i];
+      const size = sizes[i] ?? 1;
+      const px = x + xVal / maxX * w;
+      const py = y + h - yVal / maxY * h;
+      const r = Math.max(2, Math.sqrt(size / maxBubble) * maxRadius);
+      parts.push(
+        `<circle cx="${round2(px)}" cy="${round2(py)}" r="${round2(r)}" ${fillAttr(color)} fill-opacity="0.6"/>`
+      );
+    }
+  }
+  return parts.join("");
+}
+function renderRadarChart(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 cx = x + w / 2;
+  const cy = y + h / 2;
+  const radius = Math.min(w, h) / 2 * 0.85;
+  const gridLevels = 5;
+  for (let level = 1; level <= gridLevels; level++) {
+    const r = radius / gridLevels * level;
+    parts.push(
+      `<circle cx="${round2(cx)}" cy="${round2(cy)}" r="${round2(r)}" fill="none" stroke="#D9D9D9" stroke-width="0.5"/>`
+    );
+  }
+  for (let i = 0; i < catCount; i++) {
+    const angle = i / catCount * 2 * Math.PI - Math.PI / 2;
+    const ax = cx + radius * Math.cos(angle);
+    const ay = cy + radius * Math.sin(angle);
+    parts.push(
+      `<line x1="${round2(cx)}" y1="${round2(cy)}" x2="${round2(ax)}" y2="${round2(ay)}" stroke="#D9D9D9" stroke-width="0.5"/>`
+    );
+    const label = categories[i] ?? "";
+    if (label) {
+      const labelR = radius + 12;
+      const lx = cx + labelR * Math.cos(angle);
+      const ly = cy + labelR * Math.sin(angle);
+      const anchor = Math.abs(Math.cos(angle)) < 0.01 ? "middle" : Math.cos(angle) > 0 ? "start" : "end";
+      parts.push(
+        `<text x="${round2(lx)}" y="${round2(ly + 4)}" text-anchor="${anchor}" font-size="10" fill="#595959">${escapeXml2(label)}</text>`
+      );
+    }
+  }
+  const isFilled = chart.radarStyle === "filled";
+  const showMarkers = chart.radarStyle === "marker";
+  for (let s = 0; s < series.length; s++) {
+    const color = series[s].color;
+    const points = [];
+    const coords = [];
+    for (let i = 0; i < catCount; i++) {
+      const val = series[s].values[i] ?? 0;
+      const angle = i / catCount * 2 * Math.PI - Math.PI / 2;
+      const r = val / maxVal * radius;
+      const px = cx + r * Math.cos(angle);
+      const py = cy + r * Math.sin(angle);
+      points.push(`${round2(px)},${round2(py)}`);
+      coords.push({ px, py });
+    }
+    if (isFilled) {
+      parts.push(
+        `<polygon points="${points.join(" ")}" fill="${color.hex}" fill-opacity="0.3" stroke="${color.hex}" stroke-width="2"${color.alpha < 1 ? ` stroke-opacity="${color.alpha}"` : ""}/>`
+      );
+    } else {
+      parts.push(
+        `<polygon points="${points.join(" ")}" fill="none" stroke="${color.hex}" stroke-width="2"${color.alpha < 1 ? ` stroke-opacity="${color.alpha}"` : ""}/>`
+      );
+    }
+    if (showMarkers) {
+      for (const { px, py } of coords) {
+        parts.push(`<circle cx="${round2(px)}" cy="${round2(py)}" r="3" ${fillAttr(color)}/>`);
+      }
+    }
+  }
+  return parts.join("");
+}
 function renderLegend(chart, chartW, chartH, position) {
   const parts = [];
-  const entries = chart.chartType === "pie" ? chart.categories.map((cat, i) => ({
+  const entries2 = chart.chartType === "pie" || chart.chartType === "doughnut" ? 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 "";
+  if (entries2.length === 0) return "";
   const entryWidth = 80;
-  const totalWidth = entries.length * entryWidth;
+  const totalWidth = entries2.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++) {
+  for (let i = 0; i < entries2.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)}/>`
+      `<rect x="${round2(ex)}" y="${round2(legendY - 6)}" width="12" height="12" ${fillAttr(entries2[i].color)}/>`
     );
     parts.push(
-      `<text x="${round2(ex + 16)}" y="${round2(legendY + 4)}" font-size="10" fill="#595959">${escapeXml2(entries[i].label)}</text>`
+      `<text x="${round2(ex + 16)}" y="${round2(legendY + 4)}" font-size="10" fill="#595959">${escapeXml2(entries2[i].label)}</text>`
     );
   }
   return parts.join("");
@@ -4136,23 +5955,27 @@ function renderTable(element, defs) {
       );
       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}/>`);
+          const topResult = renderOutlineAttrs(cell.borders.top);
+          if (topResult.defs) defs.push(topResult.defs);
+          parts.push(`<line x1="${x}" y1="${y}" x2="${x + cellW}" y2="${y}" ${topResult.attrs}/>`);
         }
         if (cell.borders.bottom) {
-          const attrs = renderOutlineAttrs(cell.borders.bottom);
+          const bottomResult = renderOutlineAttrs(cell.borders.bottom);
+          if (bottomResult.defs) defs.push(bottomResult.defs);
           parts.push(
-            `<line x1="${x}" y1="${y + cellH}" x2="${x + cellW}" y2="${y + cellH}" ${attrs}/>`
+            `<line x1="${x}" y1="${y + cellH}" x2="${x + cellW}" y2="${y + cellH}" ${bottomResult.attrs}/>`
           );
         }
         if (cell.borders.left) {
-          const attrs = renderOutlineAttrs(cell.borders.left);
-          parts.push(`<line x1="${x}" y1="${y}" x2="${x}" y2="${y + cellH}" ${attrs}/>`);
+          const leftResult = renderOutlineAttrs(cell.borders.left);
+          if (leftResult.defs) defs.push(leftResult.defs);
+          parts.push(`<line x1="${x}" y1="${y}" x2="${x}" y2="${y + cellH}" ${leftResult.attrs}/>`);
         }
         if (cell.borders.right) {
-          const attrs = renderOutlineAttrs(cell.borders.right);
+          const rightResult = renderOutlineAttrs(cell.borders.right);
+          if (rightResult.defs) defs.push(rightResult.defs);
           parts.push(
-            `<line x1="${x + cellW}" y1="${y}" x2="${x + cellW}" y2="${y + cellH}" ${attrs}/>`
+            `<line x1="${x + cellW}" y1="${y}" x2="${x + cellW}" y2="${y + cellH}" ${rightResult.attrs}/>`
           );
         }
       }
@@ -4259,10 +6082,23 @@ function renderGroup(group, defs) {
   const chY = emuToPixels(group.childTransform.offsetY);
   const scaleX = chW !== 0 ? w / chW : 1;
   const scaleY = chH !== 0 ? h / chH : 1;
+  const transformParts = [];
+  transformParts.push(`translate(${x}, ${y})`);
+  if (group.transform.rotation !== 0) {
+    transformParts.push(`rotate(${group.transform.rotation}, ${w / 2}, ${h / 2})`);
+  }
+  if (group.transform.flipH || group.transform.flipV) {
+    const sx = group.transform.flipH ? -1 : 1;
+    const sy = group.transform.flipV ? -1 : 1;
+    transformParts.push(
+      `translate(${group.transform.flipH ? w : 0}, ${group.transform.flipV ? h : 0})`
+    );
+    transformParts.push(`scale(${sx}, ${sy})`);
+  }
+  transformParts.push(`scale(${scaleX}, ${scaleY})`);
+  transformParts.push(`translate(${-chX}, ${-chY})`);
   const parts = [];
-  parts.push(
-    `<g transform="translate(${x}, ${y}) scale(${scaleX}, ${scaleY}) translate(${-chX}, ${-chY})">`
-  );
+  parts.push(`<g transform="${transformParts.join(" ")}">`);
   for (const child of group.children) {
     const rendered = renderElement(child, defs);
     if (rendered) parts.push(rendered);
@@ -4271,17 +6107,29 @@ function renderGroup(group, defs) {
   return parts.join("");
 }
 function extractDefs(svgFragment, defs) {
-  const gradientMatch = svgFragment.match(/<linearGradient[^]*?<\/linearGradient>/g);
-  if (gradientMatch) {
-    defs.push(...gradientMatch);
+  const linearGradientMatch = svgFragment.match(/<linearGradient[^]*?<\/linearGradient>/g);
+  if (linearGradientMatch) {
+    defs.push(...linearGradientMatch);
+  }
+  const radialGradientMatch = svgFragment.match(/<radialGradient[^]*?<\/radialGradient>/g);
+  if (radialGradientMatch) {
+    defs.push(...radialGradientMatch);
+  }
+  const patternMatch = svgFragment.match(/<pattern[^]*?<\/pattern>/g);
+  if (patternMatch) {
+    defs.push(...patternMatch);
   }
   const filterMatch = svgFragment.match(/<filter[^]*?<\/filter>/g);
   if (filterMatch) {
     defs.push(...filterMatch);
   }
+  const markerMatch = svgFragment.match(/<marker[^]*?<\/marker>/g);
+  if (markerMatch) {
+    defs.push(...markerMatch);
+  }
 }
 function removeDefs(svgFragment) {
-  return svgFragment.replace(/<linearGradient[^]*?<\/linearGradient>/g, "").replace(/<filter[^]*?<\/filter>/g, "");
+  return svgFragment.replace(/<linearGradient[^]*?<\/linearGradient>/g, "").replace(/<radialGradient[^]*?<\/radialGradient>/g, "").replace(/<pattern[^]*?<\/pattern>/g, "").replace(/<filter[^]*?<\/filter>/g, "").replace(/<marker[^]*?<\/marker>/g, "");
 }
 
 // src/png/png-converter.ts
@@ -4305,8 +6153,88 @@ async function svgToPng(svgString, options) {
   };
 }
 
+// src/text-style-resolver.ts
+function applyTextStyleInheritance(elements, context) {
+  for (const element of elements) {
+    if (element.type === "shape") {
+      resolveShapeTextInheritance(element, context);
+    } else if (element.type === "group") {
+      applyTextStyleInheritance(element.children, context);
+    }
+  }
+}
+function resolveShapeTextInheritance(shape, context) {
+  if (!shape.textBody) return;
+  const layoutLstStyle = findMatchingPlaceholderStyle(
+    shape.placeholderType,
+    shape.placeholderIdx,
+    context.layoutPlaceholderStyles
+  );
+  const masterLstStyle = findMatchingPlaceholderStyle(
+    shape.placeholderType,
+    shape.placeholderIdx,
+    context.masterPlaceholderStyles
+  );
+  const txStyle = getTxStyleForPlaceholder(shape.placeholderType, context.txStyles);
+  const chainSources = [layoutLstStyle, masterLstStyle, txStyle, context.defaultTextStyle];
+  for (const paragraph of shape.textBody.paragraphs) {
+    const level = paragraph.properties.level;
+    for (const run of paragraph.runs) {
+      const props = run.properties;
+      for (const source of chainSources) {
+        if (props.fontSize !== null && props.fontFamily !== null && props.fontFamilyEa !== null && props.color !== null) {
+          break;
+        }
+        const defRPr = getDefRPrFromStyle(source, level);
+        if (!defRPr) continue;
+        if (props.fontSize === null && defRPr.fontSize !== void 0) {
+          props.fontSize = defRPr.fontSize;
+        }
+        if (props.fontFamily === null && defRPr.fontFamily != null) {
+          props.fontFamily = resolveThemeFont(defRPr.fontFamily, context.fontScheme);
+        }
+        if (props.fontFamilyEa === null && defRPr.fontFamilyEa != null) {
+          props.fontFamilyEa = resolveThemeFont(defRPr.fontFamilyEa, context.fontScheme);
+        }
+        if (props.color === null && defRPr.color !== void 0) {
+          props.color = defRPr.color;
+        }
+      }
+    }
+  }
+}
+function findMatchingPlaceholderStyle(placeholderType, placeholderIdx, styles) {
+  if (!placeholderType) return void 0;
+  if (placeholderIdx !== void 0) {
+    const byIdx = styles.find((s) => s.placeholderIdx === placeholderIdx);
+    if (byIdx?.lstStyle) return byIdx.lstStyle;
+  }
+  const byType = styles.find((s) => s.placeholderType === placeholderType);
+  return byType?.lstStyle;
+}
+function getTxStyleForPlaceholder(placeholderType, txStyles) {
+  if (!txStyles) return void 0;
+  if (!placeholderType) return txStyles.otherStyle;
+  switch (placeholderType) {
+    case "title":
+    case "ctrTitle":
+      return txStyles.titleStyle;
+    case "body":
+    case "subTitle":
+    case "obj":
+      return txStyles.bodyStyle;
+    default:
+      return txStyles.otherStyle;
+  }
+}
+function getDefRPrFromStyle(style, level) {
+  if (!style) return void 0;
+  return style.levels[level]?.defaultRunProperties ?? style.defaultParagraph?.defaultRunProperties;
+}
+
 // src/converter.ts
 async function convertPptxToSvg(input, options) {
+  initWarningLogger(options?.logLevel ?? "off");
   const archive = await readPptx(input);
   const presentationXml = archive.files.get("ppt/presentation.xml");
   if (!presentationXml) throw new Error("Invalid PPTX: missing ppt/presentation.xml");
@@ -4354,7 +6282,9 @@ async function convertPptxToSvg(input, options) {
     masterFillContext = { rels: masterRels, archive, basePath: masterPath };
   }
   const masterBackground = masterXml ? parseSlideMasterBackground(masterXml, colorResolver, masterFillContext) : null;
-  const masterElements = masterPath && masterXml ? parseSlideMasterElements(masterXml, masterPath, archive, colorResolver) : [];
+  const masterElements = masterPath && masterXml ? parseSlideMasterElements(masterXml, masterPath, archive, colorResolver, theme.fontScheme) : [];
+  const masterTxStyles = masterXml ? parseSlideMasterTxStyles(masterXml, colorResolver) : void 0;
+  const masterPlaceholderStyles = masterXml ? parseSlideMasterPlaceholderStyles(masterXml, colorResolver) : [];
   const slidePaths = [];
   for (let i = 0; i < presInfo.slideRIds.length; i++) {
     const rId = presInfo.slideRIds[i];
@@ -4369,8 +6299,10 @@ async function convertPptxToSvg(input, options) {
   for (const { slideNumber, path } of targetSlides) {
     const slideXml = archive.files.get(path);
     if (!slideXml) continue;
-    const slide = parseSlide(slideXml, path, slideNumber, archive, colorResolver);
+    const slide = parseSlide(slideXml, path, slideNumber, archive, colorResolver, theme.fontScheme);
     let layoutElements = [];
+    let layoutPlaceholderStyles = [];
+    let layoutShowMasterSp = true;
     const slideRelsPath = buildRelsPath(path);
     const slideRelsXml = archive.files.get(slideRelsPath);
     if (slideRelsXml) {
@@ -4399,8 +6331,11 @@ async function convertPptxToSvg(input, options) {
               layoutXml,
               layoutPath,
               archive,
-              colorResolver
+              colorResolver,
+              theme.fontScheme
             );
+            layoutPlaceholderStyles = parseSlideLayoutPlaceholderStyles(layoutXml, colorResolver);
+            layoutShowMasterSp = parseSlideLayoutShowMasterSp(layoutXml);
           }
           break;
         }
@@ -4409,10 +6344,19 @@ async function convertPptxToSvg(input, options) {
     if (!slide.background) {
       slide.background = masterBackground;
     }
-    slide.elements = mergeElements(masterElements, layoutElements, slide.elements);
+    applyTextStyleInheritance(slide.elements, {
+      layoutPlaceholderStyles,
+      masterPlaceholderStyles,
+      txStyles: masterTxStyles,
+      defaultTextStyle: presInfo.defaultTextStyle,
+      fontScheme: theme.fontScheme
+    });
+    const effectiveMasterElements = slide.showMasterSp && layoutShowMasterSp ? masterElements : [];
+    slide.elements = mergeElements(effectiveMasterElements, layoutElements, slide.elements);
     const svg = renderSlideToSvg(slide, presInfo.slideSize);
     results.push({ slideNumber, svg });
   }
+  flushWarnings();
   return results;
 }
 async function convertPptxToPng(input, options) {
@@ -4431,28 +6375,13 @@ async function convertPptxToPng(input, options) {
   }
   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) => {
+function mergeElements(masterElements, layoutElements, slideElements) {
+  const filterPlaceholders = (elements) => elements.filter((el) => {
     if (el.type !== "shape") return true;
-    if (!el.placeholderType) return true;
-    return !excludeTypes.has(el.placeholderType);
+    return !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);
+  const filteredMaster = filterPlaceholders(masterElements);
+  const filteredLayout = filterPlaceholders(layoutElements);
   return [...filteredMaster, ...filteredLayout, ...slideElements];
 }
 function defaultColorScheme2() {
@@ -4489,5 +6418,7 @@ function defaultColorMap() {
 }
 export {
   convertPptxToPng,
-  convertPptxToSvg
+  convertPptxToSvg,
+  getWarningEntries,
+  getWarningSummary
 };