pptx-viewer-core 1.5.0 → 1.6.0

package/dist/converter/index.mjs

@@ -1,3 +1,7 @@
+import 'fast-xml-parser';
+import 'jszip';
+import 'emf-converter';
+
 // src/converter/media-context.ts
 var MIME_TO_EXT = {
   "image/png": "png",
@@ -520,6 +524,8 @@ var FallbackElementProcessor = class {
       } else {
         parts.push(`*[Zoom to Section (Slide ${slideNumber})]*`);
       }
+    } else if (zoomElement.zoomType === "summary") {
+      parts.push(`*[Summary Zoom starting at Slide ${slideNumber}]*`);
     } else {
       parts.push(`*[Zoom to Slide ${slideNumber}]*`);
     }
@@ -3311,6 +3317,40 @@ ${footer}`;
   }
 };
 
+// src/converter/svg-image-effect-values.ts
+function clamp(value, minimum, maximum) {
+  return value < minimum ? minimum : value > maximum ? maximum : value;
+}
+function clamp01to2(value) {
+  return clamp(value, 0, 2);
+}
+function fmt(value) {
+  return Number.isFinite(value) ? Number(value.toFixed(4)).toString() : "0";
+}
+function stepTable10(threshold) {
+  return Array.from({ length: 10 }, (_, index) => index / 10 >= threshold ? "1" : "0").join(" ");
+}
+function biLevelTable(threshold) {
+  const cutoff = clamp(threshold, 0, 100);
+  return Array.from({ length: 101 }, (_, index) => index >= cutoff ? "1" : "0").join(" ");
+}
+function luminanceTransfer(amount) {
+  const normalized = clamp(amount / 100, -1, 1);
+  return normalized >= 0 ? { slope: 1 - normalized, intercept: normalized } : { slope: 1 + normalized, intercept: 0 };
+}
+function parseHexRgb(hex) {
+  const match = /^#?([0-9a-f]{6})/iu.exec(hex.trim());
+  if (!match) {
+    return { r: 0, g: 0, b: 0 };
+  }
+  const value = parseInt(match[1] ?? "000000", 16);
+  return {
+    r: (value >> 16 & 255) / 255,
+    g: (value >> 8 & 255) / 255,
+    b: (value & 255) / 255
+  };
+}
+
 // src/converter/svg-image-effects.ts
 function buildImageEffectsFilter(effects, idSuffix) {
   if (!effects) {
@@ -3335,6 +3375,20 @@ function buildImageEffectsFilter(effects, idSuffix) {
       `<feColorMatrix in="__IN__" type="hueRotate" values="${fmt(effects.hsl.hue)}" result="__OUT__"/>`
     );
   }
+  if (typeof effects.hsl?.sat === "number") {
+    const saturation = clamp01to2(1 + effects.hsl.sat / 100);
+    next(
+      "p3s",
+      `<feColorMatrix in="__IN__" type="saturate" values="${fmt(saturation)}" result="__OUT__"/>`
+    );
+  }
+  if (typeof effects.hsl?.lum === "number") {
+    const { slope, intercept } = luminanceTransfer(effects.hsl.lum);
+    next(
+      "p3l",
+      `<feComponentTransfer in="__IN__" result="__OUT__"><feFuncR type="linear" slope="${fmt(slope)}" intercept="${fmt(intercept)}"/><feFuncG type="linear" slope="${fmt(slope)}" intercept="${fmt(intercept)}"/><feFuncB type="linear" slope="${fmt(slope)}" intercept="${fmt(intercept)}"/></feComponentTransfer>`
+    );
+  }
   if (typeof effects.brightness === "number" || typeof effects.contrast === "number") {
     const b = (effects.brightness ?? 0) / 100;
     const c = 1 + (effects.contrast ?? 0) / 100;
@@ -3357,10 +3411,10 @@ function buildImageEffectsFilter(effects, idSuffix) {
   }
   if (typeof effects.biLevel === "number") {
     next("p6a", `<feColorMatrix in="__IN__" type="saturate" values="0" result="__OUT__"/>`);
-    const t = clamp(effects.biLevel / 100, 0, 1);
+    const table = biLevelTable(effects.biLevel);
     next(
       "p6b",
-      `<feComponentTransfer in="__IN__" result="__OUT__"><feFuncR type="discrete" tableValues="${t === 0 ? "1 1" : `0 ${stepTable(t)}`}"/><feFuncG type="discrete" tableValues="${t === 0 ? "1 1" : `0 ${stepTable(t)}`}"/><feFuncB type="discrete" tableValues="${t === 0 ? "1 1" : `0 ${stepTable(t)}`}"/></feComponentTransfer>`
+      `<feComponentTransfer in="__IN__" result="__OUT__"><feFuncR type="discrete" tableValues="${table}"/><feFuncG type="discrete" tableValues="${table}"/><feFuncB type="discrete" tableValues="${table}"/></feComponentTransfer>`
     );
   }
   if (effects.duotone) {
@@ -3373,19 +3427,17 @@ function buildImageEffectsFilter(effects, idSuffix) {
     );
   }
   if (effects.tint && typeof effects.tint.amt === "number") {
-    const amt = clamp(effects.tint.amt / 100, -1, 1);
-    if (amt < 0) {
-      next(
-        "p8",
-        `<feColorMatrix in="__IN__" type="saturate" values="${fmt(1 + amt)}" result="__OUT__"/>`
-      );
-    }
     if (typeof effects.tint.hue === "number") {
       next(
         "p8h",
         `<feColorMatrix in="__IN__" type="hueRotate" values="${fmt(effects.tint.hue)}" result="__OUT__"/>`
       );
     }
+    const { slope, intercept } = luminanceTransfer(effects.tint.amt);
+    next(
+      "p8",
+      `<feComponentTransfer in="__IN__" result="__OUT__"><feFuncR type="linear" slope="${fmt(slope)}" intercept="${fmt(intercept)}"/><feFuncG type="linear" slope="${fmt(slope)}" intercept="${fmt(intercept)}"/><feFuncB type="linear" slope="${fmt(slope)}" intercept="${fmt(intercept)}"/></feComponentTransfer>`
+    );
   }
   if (effects.clrRepl) {
     const c = parseHexRgb(effects.clrRepl.color);
@@ -3459,36 +3511,1849 @@ function buildImageEffectsFilter(effects, idSuffix) {
   const defsXml = `<filter id="${filterId}" x="-10%" y="-10%" width="120%" height="120%">${primitives.join("")}</filter>`;
   return { defsXml, filterId };
 }
-function clamp(v, lo, hi) {
-  return v < lo ? lo : v > hi ? hi : v;
+
+// src/core/utils/color-xml-preservation.ts
+var COLOR_CHOICE_NAMES = [
+  "srgbClr",
+  "schemeClr",
+  "sysClr",
+  "prstClr",
+  "scrgbClr",
+  "hslClr"
+];
+function extractColorChoiceXml(parent) {
+  if (!parent) {
+    return void 0;
+  }
+  for (const [key, value] of Object.entries(parent)) {
+    if (COLOR_CHOICE_NAMES.includes(key.split(":").at(-1) ?? key)) {
+      return { [key]: value };
+    }
+  }
+  return void 0;
 }
-function clamp01to2(v) {
-  return clamp(v, 0, 2);
+
+// src/core/utils/smartart-helpers.ts
+function buildForest(nodes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    map.set(n.id, { node: n, children: [] });
+  }
+  const roots = [];
+  for (const n of nodes) {
+    const tn = map.get(n.id);
+    if (n.parentId && map.has(n.parentId)) {
+      map.get(n.parentId).children.push(tn);
+    } else {
+      roots.push(tn);
+    }
+  }
+  return roots;
 }
-function fmt(v) {
-  return Number.isFinite(v) ? Number(v.toFixed(4)).toString() : "0";
+var MAX_TREE_DEPTH = 256;
+function treeWidth(t, depth = 0) {
+  if (depth >= MAX_TREE_DEPTH) {
+    return 1;
+  }
+  if (t.children.length === 0) {
+    return 1;
+  }
+  let sum = 0;
+  for (const c of t.children) {
+    sum += treeWidth(c, depth + 1);
+  }
+  return sum;
+}
+function treeDepth(t, depth = 0) {
+  if (depth >= MAX_TREE_DEPTH) {
+    return 0;
+  }
+  if (t.children.length === 0) {
+    return 1;
+  }
+  let max = 0;
+  for (const c of t.children) {
+    const d = treeDepth(c, depth + 1);
+    if (d > max) {
+      max = d;
+    }
+  }
+  return 1 + max;
 }
-function stepTable(t) {
-  return t < 0.5 ? "1" : "1";
+function getContentNodes(nodes) {
+  return nodes.filter((n) => n.text.length > 0);
 }
-function stepTable10(t) {
-  const out = [];
-  for (let i = 0; i < 10; i++) {
-    out.push(i / 10 >= t ? "1" : "0");
+
+// src/core/utils/smartart-layout-engine-algorithms.ts
+function computeSnakeLayout(nodes, constraints, bounds) {
+  const items = getContentNodes(nodes);
+  if (items.length === 0) {
+    return [];
   }
-  return out.join(" ");
+  const cols = constraints.cols ?? Math.min(4, items.length);
+  const rows = Math.ceil(items.length / cols);
+  const sibSp = (constraints.sibSp ?? 0.02) * bounds.width;
+  const secSibSp = (constraints.secSibSp ?? 0.03) * bounds.height;
+  const begPad = (constraints.begPad ?? 0.02) * bounds.width;
+  const endPad = (constraints.endPad ?? 0.02) * bounds.width;
+  const usableW = bounds.width - begPad - endPad;
+  const usableH = bounds.height - begPad - endPad;
+  const cellW = (usableW - sibSp * (cols - 1)) / cols;
+  const cellH = (usableH - secSibSp * (rows - 1)) / rows;
+  const nodeW = constraints.w ? constraints.w * bounds.width : cellW * 0.85;
+  const nodeH = constraints.h ? constraints.h * bounds.height : cellH * 0.7;
+  return items.map((node, i) => {
+    const row = Math.floor(i / cols);
+    const colInRow = i % cols;
+    const col = row % 2 === 0 ? colInRow : cols - 1 - colInRow;
+    const cx = bounds.x + begPad + col * (cellW + sibSp) + cellW / 2;
+    const cy = bounds.y + begPad + row * (cellH + secSibSp) + cellH / 2;
+    return {
+      nodeId: node.id,
+      x: Math.round(cx - nodeW / 2),
+      y: Math.round(cy - nodeH / 2),
+      width: Math.round(nodeW),
+      height: Math.round(nodeH)
+    };
+  });
 }
-function parseHexRgb(hex) {
-  const m = /^#?([0-9a-f]{6})/i.exec(hex.trim());
-  if (!m) {
-    return { r: 0, g: 0, b: 0 };
+function computeLinearLayout(nodes, constraints, bounds) {
+  const items = getContentNodes(nodes);
+  if (items.length === 0) {
+    return [];
+  }
+  const isVertical = (constraints.aspectRatio ?? 1) < 0.5;
+  const sibSp = constraints.sibSp ?? 0.03;
+  const begPad = constraints.begPad ?? 0.02;
+  const endPad = constraints.endPad ?? 0.02;
+  if (isVertical) {
+    const padTop = begPad * bounds.height;
+    const padBot = endPad * bounds.height;
+    const gap2 = sibSp * bounds.height;
+    const usableH = bounds.height - padTop - padBot;
+    const nodeH2 = (usableH - gap2 * (items.length - 1)) / items.length;
+    const nodeW2 = constraints.w ? constraints.w * bounds.width : bounds.width * 0.8;
+    const xOffset = bounds.x + (bounds.width - nodeW2) / 2;
+    return items.map((node, i) => ({
+      nodeId: node.id,
+      x: Math.round(xOffset),
+      y: Math.round(bounds.y + padTop + i * (nodeH2 + gap2)),
+      width: Math.round(nodeW2),
+      height: Math.round(nodeH2)
+    }));
+  }
+  const padLeft = begPad * bounds.width;
+  const padRight = endPad * bounds.width;
+  const gap = sibSp * bounds.width;
+  const usableW = bounds.width - padLeft - padRight;
+  const nodeW = (usableW - gap * (items.length - 1)) / items.length;
+  const nodeH = constraints.h ? constraints.h * bounds.height : bounds.height * 0.6;
+  const yOffset = bounds.y + (bounds.height - nodeH) / 2;
+  const shapes = items.map((node, i) => ({
+    nodeId: node.id,
+    x: Math.round(bounds.x + padLeft + i * (nodeW + gap)),
+    y: Math.round(yOffset),
+    width: Math.round(nodeW),
+    height: Math.round(nodeH)
+  }));
+  if (constraints.dir === "rev") {
+    shapes.reverse();
+    const positions = shapes.map((s) => ({ x: s.x, y: s.y }));
+    for (let i = 0; i < shapes.length; i++) {
+      shapes[i].x = positions[shapes.length - 1 - i].x;
+      shapes[i].y = positions[shapes.length - 1 - i].y;
+    }
+  }
+  return shapes;
+}
+function computeHierarchyLayout(nodes, constraints, bounds) {
+  const roots = buildForest(nodes);
+  if (roots.length === 0) {
+    return computeLinearLayout(nodes, constraints, bounds);
+  }
+  const totalLeaves = roots.reduce((s, r) => s + treeWidth(r), 0);
+  const depth = Math.max(...roots.map(treeDepth));
+  const begPad = (constraints.begPad ?? 0.02) * bounds.width;
+  (constraints.sibSp ?? 0.02) * bounds.width;
+  (constraints.secSibSp ?? 0.03) * bounds.height;
+  const usableW = bounds.width - begPad * 2;
+  const usableH = bounds.height - begPad * 2;
+  const cellW = usableW / Math.max(totalLeaves, 1);
+  const cellH = usableH / Math.max(depth, 1);
+  const nodeW = constraints.w ? constraints.w * bounds.width : Math.min(cellW * 0.8, 140);
+  const nodeH = constraints.h ? constraints.h * bounds.height : Math.min(cellH * 0.35, 50);
+  const shapes = [];
+  const MAX_WALK_DEPTH = 256;
+  function walk(t, xOffset, level) {
+    if (level >= MAX_WALK_DEPTH) {
+      return 1;
+    }
+    const w = treeWidth(t);
+    const cx = bounds.x + begPad + (xOffset + w / 2) * cellW;
+    const cy = bounds.y + begPad + level * cellH + cellH / 2;
+    shapes.push({
+      nodeId: t.node.id,
+      x: Math.round(cx - nodeW / 2),
+      y: Math.round(cy - nodeH / 2),
+      width: Math.round(nodeW),
+      height: Math.round(nodeH)
+    });
+    let childOffset = xOffset;
+    for (const child2 of t.children) {
+      walk(child2, childOffset, level + 1);
+      childOffset += treeWidth(child2);
+    }
+    return w;
+  }
+  let offset = 0;
+  for (const root of roots) {
+    offset += walk(root, offset, 0);
+  }
+  return shapes;
+}
+function computeCycleLayout(nodes, constraints, bounds) {
+  const items = getContentNodes(nodes);
+  if (items.length === 0) {
+    return [];
+  }
+  const size = Math.min(bounds.width, bounds.height);
+  const cx = bounds.x + bounds.width / 2;
+  const cy = bounds.y + bounds.height / 2;
+  const radius = size * 0.32;
+  const nodeW = constraints.w ? constraints.w * bounds.width : Math.max(size * 0.18, Math.min(size * 0.28, 300 / items.length));
+  const nodeH = constraints.h ? constraints.h * bounds.height : nodeW * 0.6;
+  return items.map((node, i) => {
+    const angle = i / items.length * Math.PI * 2 - Math.PI / 2;
+    const nx = cx + radius * Math.cos(angle) - nodeW / 2;
+    const ny = cy + radius * Math.sin(angle) - nodeH / 2;
+    return {
+      nodeId: node.id,
+      x: Math.round(nx),
+      y: Math.round(ny),
+      width: Math.round(nodeW),
+      height: Math.round(nodeH)
+    };
+  });
+}
+function computePyramidLayout(nodes, constraints, bounds) {
+  const items = getContentNodes(nodes);
+  if (items.length === 0) {
+    return [];
+  }
+  const begPad = (constraints.begPad ?? 0.02) * bounds.height;
+  const sibSp = (constraints.sibSp ?? 0.01) * bounds.height;
+  const usableH = bounds.height - begPad * 2;
+  const bandH = (usableH - sibSp * (items.length - 1)) / items.length;
+  const maxW = bounds.width - begPad * 2;
+  return items.map((node, i) => {
+    const widthFraction = 0.3 + i / Math.max(items.length - 1, 1) * 0.7;
+    const w = maxW * widthFraction;
+    const x = bounds.x + (bounds.width - w) / 2;
+    const y = bounds.y + begPad + i * (bandH + sibSp);
+    return {
+      nodeId: node.id,
+      x: Math.round(x),
+      y: Math.round(y),
+      width: Math.round(w),
+      height: Math.round(bandH)
+    };
+  });
+}
+function computeMatrixLayout(nodes, constraints, bounds) {
+  const items = getContentNodes(nodes);
+  if (items.length === 0) {
+    return [];
+  }
+  const cols = constraints.cols ?? Math.ceil(Math.sqrt(items.length));
+  const rows = Math.ceil(items.length / cols);
+  const begPad = (constraints.begPad ?? 0.02) * Math.min(bounds.width, bounds.height);
+  const sibSp = (constraints.sibSp ?? 0.02) * bounds.width;
+  const secSibSp = (constraints.secSibSp ?? 0.02) * bounds.height;
+  const usableW = bounds.width - begPad * 2;
+  const usableH = bounds.height - begPad * 2;
+  const cellW = (usableW - sibSp * (cols - 1)) / cols;
+  const cellH = (usableH - secSibSp * (rows - 1)) / rows;
+  return items.map((node, i) => {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    return {
+      nodeId: node.id,
+      x: Math.round(bounds.x + begPad + col * (cellW + sibSp)),
+      y: Math.round(bounds.y + begPad + row * (cellH + secSibSp)),
+      width: Math.round(cellW),
+      height: Math.round(cellH)
+    };
+  });
+}
+function computeByLayoutType(type, nodes, constraints, bounds) {
+  switch (type) {
+    case "list":
+      return computeLinearLayout(nodes, { ...constraints, aspectRatio: 0.3 }, bounds);
+    case "cycle":
+    case "relationship":
+    case "venn":
+    case "target":
+      return computeCycleLayout(nodes, constraints, bounds);
+    case "hierarchy":
+      return computeHierarchyLayout(nodes, constraints, bounds);
+    case "matrix":
+      return computeMatrixLayout(nodes, constraints, bounds);
+    case "pyramid":
+    case "funnel":
+      return computePyramidLayout(nodes, constraints, bounds);
+    case "bending":
+      return computeSnakeLayout(nodes, constraints, bounds);
+    case "gear":
+      return computeCycleLayout(nodes, { ...constraints, w: 0.2 }, bounds);
+    default:
+      return computeLinearLayout(nodes, constraints, bounds);
+  }
+}
+function resolveLayoutTypeFromString(value) {
+  const type = value?.toLowerCase() ?? "";
+  if (type.includes("hierarchy") || type.includes("org")) {
+    return "hierarchy";
+  }
+  if (type.includes("cycle") || type.includes("radial")) {
+    return "cycle";
+  }
+  if (type.includes("snake") || type.includes("bending") || type.includes("zigzag")) {
+    return "bending";
+  }
+  if (type.includes("process") || type.includes("chevron") || type.includes("arrow")) {
+    return "process";
+  }
+  if (type.includes("venn") || type.includes("relationship")) {
+    return "relationship";
+  }
+  if (type.includes("matrix")) {
+    return "matrix";
+  }
+  if (type.includes("pyramid")) {
+    return "pyramid";
+  }
+  if (type.includes("funnel")) {
+    return "funnel";
+  }
+  if (type.includes("timeline")) {
+    return "timeline";
+  }
+  if (type.includes("target") || type.includes("bullseye")) {
+    return "target";
+  }
+  if (type.includes("gear")) {
+    return "gear";
+  }
+  return "list";
+}
+function getDefaultShapeType(type) {
+  if (["cycle", "target", "gear", "relationship", "venn"].includes(type)) {
+    return "ellipse";
+  }
+  if (type === "chevron") {
+    return "chevron";
+  }
+  if (type === "pyramid" || type === "funnel") {
+    return "trapezoid";
+  }
+  return "roundRect";
+}
+
+// src/core/utils/smartart-layout-rule-evaluator.ts
+var TYPES = {
+  w: "w",
+  h: "h",
+  primfontsz: "primFontSz",
+  sp: "sp",
+  sibsp: "sibSp",
+  secsibsp: "secSibSp",
+  begpad: "begPad",
+  endpad: "endPad",
+  cols: "cols",
+  aspectratio: "aspectRatio",
+  ar: "aspectRatio",
+  dir: "dir"
+};
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function nextValue(current, rule) {
+  let value = finite(rule.val) ? rule.val : current;
+  if (!finite(value) && finite(rule.max)) {
+    value = rule.max;
+  }
+  if (!finite(value)) {
+    return void 0;
+  }
+  if (finite(rule.fact)) {
+    value *= rule.fact;
+  }
+  if (finite(rule.max)) {
+    value = Math.min(value, rule.max);
+  }
+  return Number.isFinite(value) ? value : void 0;
+}
+function pointTypeMatches(node, filter) {
+  if (!filter || filter === "all") {
+    return true;
+  }
+  const values = new Set(filter.split(/\s+/u).map((value) => value.toLowerCase()));
+  const type = (node.nodeType || "node").toLowerCase();
+  if (values.has(type)) {
+    return true;
+  }
+  if (values.has("node") && (type === "node" || type === "norm")) {
+    return true;
+  }
+  if (values.has("nonasst") && type !== "asst") {
+    return true;
+  }
+  return values.has("nonnorm") && type !== "norm" && type !== "node";
+}
+function relationshipMatches(node, rule) {
+  const relation = rule.for?.toLowerCase();
+  if (!relation) {
+    return true;
+  }
+  if (relation === "self") {
+    return !node.parentId;
+  }
+  if (relation === "ch" || relation === "des") {
+    return Boolean(node.parentId);
+  }
+  return true;
+}
+function matchingNodes(rule, nodes) {
+  const named = rule.forName?.trim();
+  const exactName = named ? nodes.some((node) => node.id === named) : false;
+  return nodes.filter(
+    (node) => (!exactName || node.id === named) && pointTypeMatches(node, rule.ptType) && relationshipMatches(node, rule)
+  );
+}
+function applyNumeric(target, type, rule, fallback) {
+  const value = nextValue(target[type] ?? fallback, rule);
+  if (value === void 0) {
+    return;
+  }
+  target[type] = type === "cols" ? Math.max(1, Math.round(value)) : Math.max(0, value);
+}
+function evaluateLayoutRules(base, rules, nodes) {
+  const constraints = { ...base };
+  const nodeConstraints = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const type = TYPES[rule.type.toLowerCase()];
+    if (!type) {
+      continue;
+    }
+    const matches = matchingNodes(rule, nodes);
+    const canTargetNode = type === "w" || type === "h" || type === "primFontSz";
+    const targeted = canTargetNode && Boolean(rule.for || rule.forName || rule.ptType);
+    if (targeted && matches.length > 0) {
+      for (const node of matches) {
+        const override = nodeConstraints.get(node.id) ?? {};
+        applyNumeric(override, type, rule, constraints[type]);
+        nodeConstraints.set(node.id, override);
+      }
+    } else if (type === "dir") {
+      const value = nextValue(constraints.dir === "rev" ? 1 : 0, rule);
+      if (value !== void 0) {
+        constraints.dir = value > 0 ? "rev" : "norm";
+      }
+    } else {
+      applyNumeric(constraints, type, rule);
+    }
+  }
+  if (constraints.sp !== void 0 && constraints.sibSp === void 0) {
+    constraints.sibSp = constraints.sp;
+  }
+  return { constraints, nodeConstraints };
+}
+function applyNodeLayoutRules(shapes, overrides, bounds, global) {
+  return shapes.map((shape) => {
+    const rule = overrides.get(shape.nodeId);
+    const widthRule = rule?.w ?? global.w;
+    const heightRule = rule?.h ?? global.h;
+    const width = widthRule !== void 0 ? widthRule * bounds.width : shape.width;
+    const height = heightRule !== void 0 ? heightRule * bounds.height : shape.height;
+    return {
+      ...shape,
+      x: Math.round(shape.x + (shape.width - width) / 2),
+      y: Math.round(shape.y + (shape.height - height) / 2),
+      width: Math.round(width),
+      height: Math.round(height),
+      fontSize: rule?.primFontSz ?? global.primFontSz
+    };
+  });
+}
+
+// src/core/core/runtime/smartart-text-paragraphs.ts
+function smartArtParagraphsText(paragraphs) {
+  return paragraphs.map(
+    (paragraph) => paragraph.items.map((item) => {
+      if (item.kind === "run") {
+        return item.run.text;
+      }
+      if (item.kind === "field") {
+        return item.text;
+      }
+      if (item.kind === "break") {
+        return "\n";
+      }
+      return item.kind === "tab" ? "	" : "";
+    }).join("")
+  ).join("\n");
+}
+
+// src/core/core/runtime/smartart-text-reconciliation.ts
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function itemText(item) {
+  if (item.kind === "run") {
+    return item.run.text;
+  }
+  return item.kind === "field" ? item.text : void 0;
+}
+function setItemText(item, text) {
+  if (item.kind === "run") {
+    item.run.text = text;
+  } else if (item.kind === "field") {
+    item.text = text;
+  }
+}
+function commonEdges(before, after) {
+  let prefix = 0;
+  while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix]) {
+    prefix++;
+  }
+  let suffix = 0;
+  while (suffix < before.length - prefix && suffix < after.length - prefix && before[before.length - 1 - suffix] === after[after.length - 1 - suffix]) {
+    suffix++;
+  }
+  return { prefix, suffix };
+}
+function separators(text) {
+  return [...text].filter((character) => character === "\n" || character === "	").join("");
+}
+function textRegions(paragraphs) {
+  const regions = [];
+  let current = [];
+  for (const paragraph of paragraphs) {
+    for (const item of paragraph.items) {
+      if (item.kind === "tab" || item.kind === "break") {
+        regions.push(current);
+        current = [];
+      } else if (itemText(item) !== void 0) {
+        current.push(item);
+      }
+    }
+    regions.push(current);
+    current = [];
+  }
+  return regions;
+}
+function desiredRegions(text) {
+  return text.split(/[\t\n]/u);
+}
+function reconcileRegion(items, desired) {
+  if (items.length === 0) {
+    return;
+  }
+  const texts = items.map((item) => itemText(item) ?? "");
+  const before = texts.join("");
+  if (before === desired) {
+    return;
+  }
+  const { prefix, suffix } = commonEdges(before, desired);
+  const removeStart = prefix;
+  const removeEnd = before.length - suffix;
+  const insertion = desired.slice(prefix, desired.length - suffix);
+  let offset = 0;
+  const affected = [];
+  for (let index = 0; index < texts.length; index++) {
+    const start = offset;
+    const end = start + texts[index].length;
+    const localStart = Math.max(0, removeStart - start);
+    const localEnd = Math.min(texts[index].length, removeEnd - start);
+    if (localEnd > localStart) {
+      affected.push({ index, start: localStart, end: localEnd, removed: localEnd - localStart });
+    }
+    offset = end;
+  }
+  if (affected.length === 0) {
+    let owner = 0;
+    let cursor = 0;
+    for (let index = 0; index < texts.length; index++) {
+      if (removeStart <= cursor + texts[index].length) {
+        owner = index;
+        break;
+      }
+      cursor += texts[index].length;
+    }
+    affected.push({
+      index: owner,
+      start: removeStart - cursor,
+      end: removeStart - cursor,
+      removed: 0
+    });
+  }
+  let insertionOffset = 0;
+  for (let affectedIndex = 0; affectedIndex < affected.length; affectedIndex++) {
+    const entry = affected[affectedIndex];
+    const isLast = affectedIndex === affected.length - 1;
+    const take = isLast ? insertion.length - insertionOffset : Math.min(entry.removed, insertion.length - insertionOffset);
+    const allocated = insertion.slice(insertionOffset, insertionOffset + Math.max(0, take));
+    insertionOffset += Math.max(0, take);
+    const original = texts[entry.index];
+    setItemText(
+      items[entry.index],
+      original.slice(0, entry.start) + allocated + original.slice(entry.end)
+    );
+  }
+}
+function reconcileWithoutStructuralChange(paragraphs, desired) {
+  const regions = textRegions(paragraphs);
+  const targets = desiredRegions(desired);
+  for (let index = 0; index < regions.length; index++) {
+    reconcileRegion(regions[index], targets[index] ?? "");
+  }
+}
+function atoms(paragraphs) {
+  const result = [];
+  for (let paragraph = 0; paragraph < paragraphs.length; paragraph++) {
+    for (let item = 0; item < paragraphs[paragraph].items.length; item++) {
+      const entry = paragraphs[paragraph].items[item];
+      const text = itemText(entry);
+      if (text !== void 0) {
+        for (let character = 0; character < text.length; character++) {
+          result.push({ kind: "text", paragraph, item, character });
+        }
+      } else if (entry.kind === "tab" || entry.kind === "break") {
+        result.push({ kind: "item", paragraph, item });
+      }
+    }
+    if (paragraph < paragraphs.length - 1) {
+      result.push({ kind: "paragraph", paragraph });
+    }
+  }
+  return result;
+}
+function removeRange(paragraphs, start, end) {
+  const selected = atoms(paragraphs).slice(start, end);
+  for (const atom of selected.reverse()) {
+    if (atom.kind === "text") {
+      const item = paragraphs[atom.paragraph]?.items[atom.item];
+      const text = item ? itemText(item) : void 0;
+      if (item && text !== void 0) {
+        setItemText(item, text.slice(0, atom.character) + text.slice(atom.character + 1));
+      }
+    } else if (atom.kind === "item") {
+      paragraphs[atom.paragraph]?.items.splice(atom.item, 1);
+    } else {
+      const left = paragraphs[atom.paragraph];
+      const right = paragraphs[atom.paragraph + 1];
+      if (left && right) {
+        left.items.push(...right.items);
+        left.endParaRPr = right.endParaRPr ?? left.endParaRPr;
+        paragraphs.splice(atom.paragraph + 1, 1);
+      }
+    }
+  }
+}
+function textTemplate(paragraph) {
+  const existing = paragraph.items.find((item) => itemText(item) !== void 0);
+  return existing ? clone(existing) : { kind: "run", run: { text: "" } };
+}
+function insertAt(paragraphs, offset, value) {
+  const location = atoms(paragraphs)[offset - 1];
+  let paragraphIndex = location?.paragraph ?? 0;
+  let itemIndex = location?.kind === "paragraph" ? paragraphs[paragraphIndex].items.length : location?.item ?? -1;
+  let textOffset = location?.kind === "text" ? location.character + 1 : void 0;
+  for (const part of value.split(/([\t\n])/u).filter((segment) => segment.length > 0)) {
+    const paragraph = paragraphs[paragraphIndex] ??= { items: [] };
+    let splitRight;
+    if ((part === "	" || part === "\n") && textOffset !== void 0) {
+      const item = paragraph.items[itemIndex];
+      const text = item ? itemText(item) : void 0;
+      if (item && text !== void 0 && textOffset > 0 && textOffset < text.length) {
+        splitRight = clone(item);
+        setItemText(item, text.slice(0, textOffset));
+        setItemText(splitRight, text.slice(textOffset));
+        paragraph.items.splice(itemIndex + 1, 0, splitRight);
+      }
+    }
+    if (part === "	") {
+      paragraph.items.splice(++itemIndex, 0, { kind: "tab" });
+      if (splitRight) {
+        itemIndex++;
+        textOffset = 0;
+      } else {
+        textOffset = void 0;
+      }
+    } else if (part === "\n") {
+      const rightItems = paragraph.items.splice(itemIndex + 1);
+      const next = clone(paragraph);
+      next.items = rightItems;
+      paragraphs.splice(paragraphIndex + 1, 0, next);
+      paragraphIndex++;
+      itemIndex = -1;
+      textOffset = void 0;
+    } else {
+      let item = paragraph.items[itemIndex];
+      if (!item || itemText(item) === void 0) {
+        item = textTemplate(paragraph);
+        setItemText(item, "");
+        paragraph.items.splice(++itemIndex, 0, item);
+      }
+      const text = itemText(item) ?? "";
+      const insertionPoint = textOffset ?? text.length;
+      setItemText(item, text.slice(0, insertionPoint) + part + text.slice(insertionPoint));
+      textOffset = insertionPoint + part.length;
+    }
+  }
+}
+function reconcileSmartArtTextParagraphs(paragraphs, desired) {
+  const result = clone(paragraphs);
+  const before = smartArtParagraphsText(result);
+  if (before === desired) {
+    return result;
+  }
+  if (separators(before) === separators(desired)) {
+    reconcileWithoutStructuralChange(result, desired);
+    return result;
+  }
+  const { prefix, suffix } = commonEdges(before, desired);
+  removeRange(result, prefix, before.length - suffix);
+  insertAt(result, prefix, desired.slice(prefix, desired.length - suffix));
+  return result.length > 0 ? result : [{ items: [] }];
+}
+
+// src/core/utils/paragraph-properties-parser.ts
+var EMU_PER_PX2 = 9525;
+function parseBoolAttr(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  return normalized === "1" || normalized === "true";
+}
+function pointsToPixels(points) {
+  return points * (96 / 72);
+}
+var ALIGN_MAP = {
+  l: "left",
+  ctr: "center",
+  r: "right",
+  just: "justify",
+  justify: "justify",
+  justLow: "justLow",
+  dist: "dist",
+  thaiDist: "thaiDist"
+};
+function parseAlignmentAttr(algn) {
+  if (!algn) {
+    return void 0;
+  }
+  return ALIGN_MAP[algn] || void 0;
+}
+function parseParagraphSpacingPx(spacingNode) {
+  if (!spacingNode) {
+    return void 0;
+  }
+  const spcPts = spacingNode["a:spcPts"];
+  const raw = Number.parseInt(String(spcPts?.["@_val"] || ""), 10);
+  if (Number.isFinite(raw)) {
+    return pointsToPixels(raw / 100);
+  }
+  return void 0;
+}
+function parseLineSpacingMultiplier(lineSpacingNode) {
+  if (!lineSpacingNode) {
+    return void 0;
+  }
+  const spcPct = lineSpacingNode["a:spcPct"];
+  const raw = Number.parseInt(String(spcPct?.["@_val"] || ""), 10);
+  if (Number.isFinite(raw)) {
+    return Math.max(0.1, Math.min(5, raw / 1e5));
+  }
+  return void 0;
+}
+function parseLineSpacingExactPt(lineSpacingNode) {
+  if (!lineSpacingNode) {
+    return void 0;
+  }
+  const spcPts = lineSpacingNode["a:spcPts"];
+  const raw = Number.parseInt(String(spcPts?.["@_val"] || ""), 10);
+  if (Number.isFinite(raw) && raw > 0) {
+    return raw / 100;
   }
-  const v = parseInt(m[1] ?? "000000", 16);
+  return void 0;
+}
+function parseParagraphMargins(pPr) {
+  const result = {};
+  if (!pPr) {
+    return result;
+  }
+  if (pPr["@_marL"] !== void 0) {
+    const marL = Number.parseInt(String(pPr["@_marL"]), 10);
+    if (Number.isFinite(marL)) {
+      result.paragraphMarginLeft = marL / EMU_PER_PX2;
+    }
+  }
+  if (pPr["@_marR"] !== void 0) {
+    const marR = Number.parseInt(String(pPr["@_marR"]), 10);
+    if (Number.isFinite(marR)) {
+      result.paragraphMarginRight = marR / EMU_PER_PX2;
+    }
+  }
+  if (pPr["@_indent"] !== void 0) {
+    const indent = Number.parseInt(String(pPr["@_indent"]), 10);
+    if (Number.isFinite(indent)) {
+      result.paragraphIndent = indent / EMU_PER_PX2;
+    }
+  }
+  return result;
+}
+function parseParagraphRtl(pPr) {
+  if (!pPr) {
+    return void 0;
+  }
+  return parseBoolAttr(pPr["@_rtl"]);
+}
+function parseParagraphLevel(pPr) {
+  if (!pPr) {
+    return 0;
+  }
+  const level = Number.parseInt(String(pPr["@_lvl"] || "0"), 10);
+  return Number.isFinite(level) ? Math.min(Math.max(level, 0), 8) : 0;
+}
+function parseTabStops(pPr) {
+  if (!pPr) {
+    return void 0;
+  }
+  const tabLst = pPr["a:tabLst"];
+  if (!tabLst) {
+    return void 0;
+  }
+  const tabNodes = Array.isArray(tabLst["a:tab"]) ? tabLst["a:tab"] : tabLst["a:tab"] ? [tabLst["a:tab"]] : [];
+  if (tabNodes.length === 0) {
+    return void 0;
+  }
+  return tabNodes.filter((t) => t?.["@_pos"] !== void 0).map((t) => {
+    const posRaw = Number.parseInt(String(t["@_pos"]), 10);
+    const position = Number.isFinite(posRaw) ? posRaw / EMU_PER_PX2 : 0;
+    const algn = String(t["@_algn"] || "l").trim();
+    const align = algn === "ctr" || algn === "r" || algn === "dec" ? algn : "l";
+    const leaderVal = String(t["@_leader"] || "").trim();
+    const leader = leaderVal === "dot" || leaderVal === "hyphen" || leaderVal === "underscore" ? leaderVal : void 0;
+    return { position, align, ...leader ? { leader } : {} };
+  });
+}
+function parseParagraphExtraAttributes(pPr) {
+  const result = {};
+  if (!pPr) {
+    return result;
+  }
+  if (pPr["@_defTabSz"] !== void 0) {
+    const defTabSz = Number.parseInt(String(pPr["@_defTabSz"]), 10);
+    if (Number.isFinite(defTabSz)) {
+      result.defaultTabSize = defTabSz / EMU_PER_PX2;
+    }
+  }
+  const eaVal = parseBoolAttr(pPr["@_eaLnBrk"]);
+  if (eaVal !== void 0) {
+    result.eaLineBreak = eaVal;
+  }
+  const latVal = parseBoolAttr(pPr["@_latinLnBrk"]);
+  if (latVal !== void 0) {
+    result.latinLineBreak = latVal;
+  }
+  if (pPr["@_fontAlgn"] !== void 0) {
+    const fontAlgn = String(pPr["@_fontAlgn"]).trim();
+    if (fontAlgn) {
+      result.fontAlignment = fontAlgn;
+    }
+  }
+  const hpVal = parseBoolAttr(pPr["@_hangingPunct"]);
+  if (hpVal !== void 0) {
+    result.hangingPunctuation = hpVal;
+  }
+  return result;
+}
+function parseBulletInfo(pPr, paragraphIndex = 0) {
+  if (!pPr) {
+    return null;
+  }
+  if (pPr["a:buNone"]) {
+    return { none: true };
+  }
+  const buFont = pPr["a:buFont"];
+  const fontFamily = buFont?.["@_typeface"] ? String(buFont["@_typeface"]) : void 0;
+  const buSzPct = pPr["a:buSzPct"];
+  let sizePercent;
+  if (buSzPct?.["@_val"] !== void 0) {
+    const pctRaw = Number.parseInt(String(buSzPct["@_val"]), 10);
+    if (Number.isFinite(pctRaw)) {
+      sizePercent = pctRaw / 1e3;
+    }
+  }
+  const buSzPts = pPr["a:buSzPts"];
+  let sizePts;
+  if (buSzPts?.["@_val"] !== void 0) {
+    const ptsRaw = Number.parseInt(String(buSzPts["@_val"]), 10);
+    if (Number.isFinite(ptsRaw)) {
+      sizePts = ptsRaw / 100;
+    }
+  }
+  const buClr = pPr["a:buClr"];
+  let color2;
+  if (buClr) {
+    const srgb = buClr["a:srgbClr"];
+    if (srgb?.["@_val"]) {
+      color2 = String(srgb["@_val"]);
+    }
+  }
+  const buChar = pPr["a:buChar"];
+  if (buChar?.["@_char"]) {
+    const char = String(buChar["@_char"]);
+    if (char.length > 0) {
+      return { char, fontFamily, sizePercent, sizePts, color: color2 };
+    }
+  }
+  const autoNum = pPr["a:buAutoNum"];
+  if (autoNum) {
+    const autoNumType = autoNum["@_type"] ? String(autoNum["@_type"]) : void 0;
+    const startAtRaw = Number.parseInt(String(autoNum["@_startAt"] || "1"), 10);
+    const autoNumStartAt = Number.isFinite(startAtRaw) ? startAtRaw : 1;
+    return {
+      autoNumType,
+      autoNumStartAt,
+      paragraphIndex,
+      fontFamily,
+      sizePercent,
+      sizePts,
+      color: color2
+    };
+  }
+  return null;
+}
+
+// src/core/utils/text-run-properties-parser.ts
+function parseBoolAttr2(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  return normalized === "1" || normalized === "true";
+}
+function parseRunPropertyAttributes(rPr) {
+  const style = {};
+  if (!rPr) {
+    return style;
+  }
+  if (rPr["@_sz"] !== void 0) {
+    const hundredths = parseInt(String(rPr["@_sz"]), 10);
+    if (Number.isFinite(hundredths)) {
+      const points = hundredths / 100;
+      style.fontSize = points * (96 / 72);
+    }
+  }
+  if (rPr["@_b"] !== void 0) {
+    style.bold = rPr["@_b"] === "1";
+  }
+  if (rPr["@_i"] !== void 0) {
+    style.italic = rPr["@_i"] === "1";
+  }
+  if (rPr["@_u"] !== void 0) {
+    const underlineToken = String(rPr["@_u"] || "").trim().toLowerCase();
+    style.underline = underlineToken.length > 0 && underlineToken !== "none" && underlineToken !== "0" && underlineToken !== "false";
+    if (style.underline) {
+      const rawU = String(rPr["@_u"] || "").trim();
+      if (rawU.length > 0 && rawU !== "none") {
+        style.underlineStyle = rawU;
+      }
+    }
+  }
+  if (rPr["@_strike"] !== void 0) {
+    const strikeToken = String(rPr["@_strike"] || "").trim().toLowerCase();
+    style.strikethrough = strikeToken.length > 0 && strikeToken !== "nostrike" && strikeToken !== "none" && strikeToken !== "0" && strikeToken !== "false";
+    if (style.strikethrough) {
+      style.strikeType = strikeToken === "dblstrike" ? "dblStrike" : "sngStrike";
+    }
+  }
+  const capAttr = String(rPr["@_cap"] || "").trim().toLowerCase();
+  if (capAttr === "all" || capAttr === "small") {
+    style.textCaps = capAttr;
+  }
+  if (rPr["@_baseline"] !== void 0) {
+    const baselineVal = Number.parseInt(String(rPr["@_baseline"]), 10);
+    if (Number.isFinite(baselineVal) && baselineVal !== 0) {
+      style.baseline = baselineVal;
+    }
+  }
+  if (rPr["@_spc"] !== void 0) {
+    const spcVal = Number.parseInt(String(rPr["@_spc"]), 10);
+    if (Number.isFinite(spcVal)) {
+      style.characterSpacing = spcVal;
+    }
+  }
+  if (rPr["@_kern"] !== void 0) {
+    const kernVal = Number.parseInt(String(rPr["@_kern"]), 10);
+    if (Number.isFinite(kernVal)) {
+      style.kerning = kernVal;
+    }
+  }
+  const langAttr = String(rPr["@_lang"] || "").trim();
+  if (langAttr) {
+    style.language = langAttr;
+  }
+  const runRtl = parseBoolAttr2(rPr["@_rtl"]);
+  if (runRtl !== void 0) {
+    style.rtl = runRtl;
+  }
+  const kumimoji = parseBoolAttr2(rPr["@_kumimoji"]);
+  if (kumimoji !== void 0) {
+    style.kumimoji = kumimoji;
+  }
+  const normalizeH = parseBoolAttr2(rPr["@_normalizeH"]);
+  if (normalizeH !== void 0) {
+    style.normalizeHeight = normalizeH;
+  }
+  const noProof = parseBoolAttr2(rPr["@_noProof"]);
+  if (noProof !== void 0) {
+    style.noProof = noProof;
+  }
+  const dirty = parseBoolAttr2(rPr["@_dirty"]);
+  if (dirty !== void 0) {
+    style.dirty = dirty;
+  }
+  const err = parseBoolAttr2(rPr["@_err"]);
+  if (err !== void 0) {
+    style.spellingError = err;
+  }
+  const smtClean = parseBoolAttr2(rPr["@_smtClean"]);
+  if (smtClean !== void 0) {
+    style.smartTagClean = smtClean;
+  }
+  const bmk = String(rPr["@_bmk"] || "").trim();
+  if (bmk) {
+    style.bookmark = bmk;
+  }
+  const altLang = String(rPr["@_altLang"] || "").trim();
+  if (altLang) {
+    style.altLanguage = altLang;
+  }
+  if (rPr["@_smtId"] !== void 0) {
+    const smtIdRaw = Number.parseInt(String(rPr["@_smtId"]), 10);
+    if (Number.isFinite(smtIdRaw)) {
+      style.smartTagId = smtIdRaw;
+    }
+  }
+  return style;
+}
+function parseTextFontMetadata(node) {
+  if (!node) {
+    return {};
+  }
+  const out = {};
+  const panose = String(node["@_panose"] || "").trim();
+  if (panose) {
+    out.panose = panose;
+  }
+  if (node["@_pitchFamily"] !== void 0) {
+    const pitchRaw = Number.parseInt(String(node["@_pitchFamily"]), 10);
+    if (Number.isFinite(pitchRaw)) {
+      out.pitchFamily = pitchRaw;
+    }
+  }
+  if (node["@_charset"] !== void 0) {
+    const charsetRaw = Number.parseInt(String(node["@_charset"]), 10);
+    if (Number.isFinite(charsetRaw)) {
+      out.charset = charsetRaw;
+    }
+  }
+  return out;
+}
+function parseRunFontElements(rPr) {
+  const result = {};
+  if (!rPr) {
+    return result;
+  }
+  const latin = rPr["a:latin"];
+  const eastAsian = rPr["a:ea"];
+  const complexScript = rPr["a:cs"];
+  const chosenTypeface = latin?.["@_typeface"] || eastAsian?.["@_typeface"] || complexScript?.["@_typeface"];
+  if (typeof chosenTypeface === "string" && chosenTypeface.trim().length > 0) {
+    result.fontFamily = chosenTypeface.trim();
+  }
+  if (typeof eastAsian?.["@_typeface"] === "string" && eastAsian["@_typeface"].trim().length > 0) {
+    result.eastAsiaFont = eastAsian["@_typeface"].trim();
+  }
+  if (typeof complexScript?.["@_typeface"] === "string" && complexScript["@_typeface"].trim().length > 0) {
+    result.complexScriptFont = complexScript["@_typeface"].trim();
+  }
+  const latinMeta = parseTextFontMetadata(latin);
+  if (latinMeta.panose !== void 0) {
+    result.latinFontPanose = latinMeta.panose;
+  }
+  if (latinMeta.pitchFamily !== void 0) {
+    result.latinFontPitchFamily = latinMeta.pitchFamily;
+  }
+  if (latinMeta.charset !== void 0) {
+    result.latinFontCharset = latinMeta.charset;
+  }
+  const eaMeta = parseTextFontMetadata(eastAsian);
+  if (eaMeta.panose !== void 0) {
+    result.eastAsiaFontPanose = eaMeta.panose;
+  }
+  if (eaMeta.pitchFamily !== void 0) {
+    result.eastAsiaFontPitchFamily = eaMeta.pitchFamily;
+  }
+  if (eaMeta.charset !== void 0) {
+    result.eastAsiaFontCharset = eaMeta.charset;
+  }
+  const csMeta = parseTextFontMetadata(complexScript);
+  if (csMeta.panose !== void 0) {
+    result.complexScriptFontPanose = csMeta.panose;
+  }
+  if (csMeta.pitchFamily !== void 0) {
+    result.complexScriptFontPitchFamily = csMeta.pitchFamily;
+  }
+  if (csMeta.charset !== void 0) {
+    result.complexScriptFontCharset = csMeta.charset;
+  }
+  return result;
+}
+function parseRunSolidFillColor(rPr) {
+  if (!rPr) {
+    return void 0;
+  }
+  const solidFill = rPr["a:solidFill"];
+  if (!solidFill) {
+    return void 0;
+  }
+  const srgb = solidFill["a:srgbClr"];
+  if (srgb?.["@_val"]) {
+    return String(srgb["@_val"]);
+  }
+  return void 0;
+}
+function parseRunSolidFillColorXml(rPr) {
+  if (!rPr) {
+    return void 0;
+  }
+  const solidFill = rPr["a:solidFill"];
+  if (!solidFill) {
+    return void 0;
+  }
+  return extractColorChoiceXml(solidFill);
+}
+
+// src/core/utils/smartart-node-text-projection.ts
+function child(node, name) {
+  if (!node) {
+    return void 0;
+  }
+  const key = Object.keys(node).find((candidate) => candidate.split(":").pop() === name);
+  const value = key ? node[key] : void 0;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function runStyle(rPr, fallback) {
+  const xml = rPr;
+  const color2 = parseRunSolidFillColor(xml);
+  const extLst = child(rPr, "extLst");
   return {
-    r: (v >> 16 & 255) / 255,
-    g: (v >> 8 & 255) / 255,
-    b: (v & 255) / 255
+    ...fallback,
+    ...parseRunPropertyAttributes(xml),
+    ...parseRunFontElements(xml),
+    ...color2 ? { color: color2.startsWith("#") ? color2 : `#${color2}` } : {},
+    ...parseRunSolidFillColorXml(xml) ? { colorXml: parseRunSolidFillColorXml(xml) } : {},
+    ...extLst ? { runPropertiesExtLstXml: extLst } : {},
+    ...xml ? { runPropertiesXml: xml } : {}
+  };
+}
+function resolvedRunStyle(rPr, resolved, fallback) {
+  return {
+    ...runStyle(rPr, fallback),
+    ...resolved,
+    ...rPr ? { runPropertiesXml: rPr } : {}
+  };
+}
+function paragraphStyle(paragraph, fallback) {
+  const pPr = paragraph.pPr;
+  const align = parseAlignmentAttr(pPr?.["@_algn"]);
+  const rtl = parseParagraphRtl(pPr);
+  const tabStops = parseTabStops(pPr);
+  const extLst = child(paragraph.pPr, "extLst");
+  return {
+    ...fallback,
+    ...align ? { align } : {},
+    ...parseParagraphMargins(pPr),
+    ...parseParagraphExtraAttributes(pPr),
+    ...rtl !== void 0 ? { rtl } : {},
+    ...tabStops ? { tabStops } : {},
+    ...parseParagraphSpacingPx(child(paragraph.pPr, "spcBef")) !== void 0 ? { paragraphSpacingBefore: parseParagraphSpacingPx(child(paragraph.pPr, "spcBef")) } : {},
+    ...parseParagraphSpacingPx(child(paragraph.pPr, "spcAft")) !== void 0 ? { paragraphSpacingAfter: parseParagraphSpacingPx(child(paragraph.pPr, "spcAft")) } : {},
+    ...parseLineSpacingMultiplier(child(paragraph.pPr, "lnSpc")) !== void 0 ? { lineSpacing: parseLineSpacingMultiplier(child(paragraph.pPr, "lnSpc")) } : {},
+    ...parseLineSpacingExactPt(child(paragraph.pPr, "lnSpc")) !== void 0 ? { lineSpacingExactPt: parseLineSpacingExactPt(child(paragraph.pPr, "lnSpc")) } : {},
+    ...extLst ? { paragraphPropertiesExtLstXml: extLst } : {},
+    ...child(paragraph.pPr, "defRPr") ? { paragraphDefaultRunPropertiesXml: child(paragraph.pPr, "defRPr") } : {}
+  };
+}
+function paragraphMetadata(paragraph, paragraphIndex) {
+  const pPr = paragraph.pPr;
+  const bulletInfo = parseBulletInfo(pPr, paragraphIndex) ?? void 0;
+  return {
+    ...bulletInfo ? { bulletInfo } : {},
+    paragraphLevel: parseParagraphLevel(pPr),
+    ...paragraph.endParaRPr ? { endParaRunProperties: paragraph.endParaRPr } : {}
+  };
+}
+function projectSmartArtNodeText(node, fallbackStyle = {}) {
+  if (!node.paragraphs?.length) {
+    return [{ text: node.text, style: fallbackStyle }];
+  }
+  const paragraphs = reconcileSmartArtTextParagraphs(node.paragraphs, node.text);
+  const segments = [];
+  for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex++) {
+    const paragraph = paragraphs[paragraphIndex];
+    const pStyle = paragraphStyle(paragraph, fallbackStyle);
+    const metadata = paragraphMetadata(paragraph, paragraphIndex);
+    let first = true;
+    const push = (segment) => {
+      segments.push(first ? { ...segment, ...metadata } : segment);
+      first = false;
+    };
+    for (const item of paragraph.items) {
+      if (item.kind === "run") {
+        push({
+          text: item.run.text,
+          style: resolvedRunStyle(item.run.rPr, item.run.style, pStyle)
+        });
+      } else if (item.kind === "field") {
+        push({
+          text: item.text,
+          style: resolvedRunStyle(item.rPr, item.style, pStyle),
+          fieldType: item.fieldType,
+          fieldGuid: item.id,
+          fieldParagraphPropertiesXml: item.pPr
+        });
+      } else if (item.kind === "break") {
+        push({
+          text: "\n",
+          style: resolvedRunStyle(item.rPr, item.style, pStyle),
+          isLineBreak: true,
+          breakRunProperties: item.rPr
+        });
+      } else if (item.kind === "tab") {
+        push({ text: "	", style: pStyle });
+      }
+    }
+    if (first) {
+      push({ text: "", style: { ...pStyle, ...paragraph.endParaStyle } });
+    }
+    if (paragraphIndex < paragraphs.length - 1) {
+      segments.push({
+        text: "",
+        style: { ...pStyle, ...paragraph.endParaStyle },
+        isParagraphBreak: true
+      });
+    }
+  }
+  return segments;
+}
+
+// src/core/utils/smartart-layout-engine.ts
+function computeSmartArtLayout(data, bounds, layoutDef) {
+  const nodes = data.nodes;
+  if (!nodes || nodes.length === 0) {
+    return void 0;
+  }
+  const contentNodes = getContentNodes(nodes);
+  if (contentNodes.length === 0) {
+    return void 0;
+  }
+  const evaluated = evaluateLayoutRules(
+    {},
+    [],
+    contentNodes
+  );
+  const constraints = evaluated.constraints;
+  const resolvedType = data.resolvedLayoutType;
+  const shapes = resolvedType ? computeByLayoutType(resolvedType, nodes, constraints, bounds) : computeByLayoutType(
+    resolveLayoutTypeFromString(data.layoutType),
+    nodes,
+    constraints,
+    bounds
+  );
+  return applyNodeLayoutRules(shapes, evaluated.nodeConstraints, bounds, constraints);
+}
+function layoutEngineShapesToDrawingShapes(engineShapes, nodes, layoutType) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    nodeMap.set(n.id, n);
+  }
+  return engineShapes.map((shape) => {
+    const node = nodeMap.get(shape.nodeId);
+    const shapeType = getDefaultShapeType(layoutType);
+    return {
+      id: `engine-${shape.nodeId}`,
+      shapeType,
+      x: shape.x,
+      y: shape.y,
+      width: shape.width,
+      height: shape.height,
+      fontSize: shape.fontSize,
+      text: node?.text,
+      textSegments: node ? projectSmartArtNodeText(node, {
+        ...shape.fontSize !== void 0 ? { fontSize: shape.fontSize * (96 / 72) } : {}
+      }) : void 0
+    };
+  });
+}
+
+// src/core/utils/mc-capabilities.ts
+var MC_NAMESPACE_CAPABILITIES = {
+  p14: /* @__PURE__ */ new Set([
+    "transition",
+    "conveyor",
+    "pan",
+    "glitter",
+    "prism",
+    "vortex",
+    "switch",
+    "flip",
+    "gallery",
+    "honeycomb",
+    "flash",
+    "shred",
+    "warp",
+    "flythrough",
+    "doors",
+    "window",
+    "ferris",
+    "newsflash",
+    "wheelReverse",
+    "rotate",
+    "orbit",
+    "cube",
+    "media",
+    "trim",
+    "fade",
+    "bmkLst",
+    "bmk",
+    "hiddenFill",
+    "hiddenLine"
+  ]),
+  a14: /* @__PURE__ */ new Set(["m", "hiddenFill", "hiddenLine", "imgEffect", "imgLayer"]),
+  a16: /* @__PURE__ */ new Set(["svgBlip", "colId"]),
+  asvg: /* @__PURE__ */ new Set(["svgBlip"]),
+  aink: /* @__PURE__ */ new Set(["ink", "inkBrush", "trace"]),
+  p16: /* @__PURE__ */ new Set(["model3D", "spPr", "model3Drel", "posterImage"]),
+  pslz: /* @__PURE__ */ new Set(["sldZm", "sldZmObj", "zmPr", "extLst"]),
+  psezm: /* @__PURE__ */ new Set(["sectionZm", "sectionZmObj", "zmPr", "extLst"]),
+  psuz: /* @__PURE__ */ new Set(["summaryZm", "summaryZmObj", "zmPr", "gridLayout", "fixedLayout", "extLst"]),
+  cx: /* @__PURE__ */ new Set(["chart", "plotArea", "plotAreaRegion", "series", "data", "numDim", "strDim"])
+};
+new Set(Object.keys(MC_NAMESPACE_CAPABILITIES));
+
+// src/core/utils/vml-parser.ts
+var VML_SHAPE_TAGS = /* @__PURE__ */ new Set([
+  "v:shape",
+  "v:rect",
+  "v:oval",
+  "v:line",
+  "v:roundrect",
+  "v:polyline",
+  "v:arc",
+  "v:group",
+  "v:image"
+]);
+
+// src/core/utils/alternate-content.ts
+/* @__PURE__ */ new Set([
+  "p:sp",
+  "p:pic",
+  "p:graphicFrame",
+  "p:grpSp",
+  "p:cxnSp",
+  "p:contentPart",
+  "p16:model3D",
+  "pslz:sldZm",
+  "psezm:sectionZm",
+  "psuz:summaryZm",
+  ...VML_SHAPE_TAGS
+]);
+
+// src/core/utils/strict-namespace-map.ts
+var NAMESPACE_PAIRS = [
+  // -- PresentationML --
+  [
+    "http://purl.oclc.org/ooxml/presentationml/main",
+    "http://schemas.openxmlformats.org/presentationml/2006/main"
+  ],
+  // -- DrawingML --
+  [
+    "http://purl.oclc.org/ooxml/drawingml/main",
+    "http://schemas.openxmlformats.org/drawingml/2006/main"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/drawingml/chart",
+    "http://schemas.openxmlformats.org/drawingml/2006/chart"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/drawingml/chartDrawing",
+    "http://schemas.openxmlformats.org/drawingml/2006/chartDrawing"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/drawingml/diagram",
+    "http://schemas.openxmlformats.org/drawingml/2006/diagram"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/drawingml/lockedCanvas",
+    "http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/drawingml/picture",
+    "http://schemas.openxmlformats.org/drawingml/2006/picture"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/drawingml/spreadsheetDrawing",
+    "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing",
+    "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
+  ],
+  // -- Relationships --
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/chart",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/comments",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/customXml",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/diagramColors",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramColors"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/diagramData",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramData"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/diagramLayout",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramLayout"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/diagramStyle",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramStyle"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/extended-properties",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/font",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/handoutMaster",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/handoutMaster"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/hyperlink",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/image",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/media",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/media"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/notesMaster",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/notesSlide",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/oleObject",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/presProps",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/presProps"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/slide",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/slideLayout",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/slideMaster",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/tags",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/theme",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/themeOverride",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/themeOverride"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/video",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/video"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/audio",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/viewProps",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/viewProps"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/tableStyles",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/tableStyles"
+  ],
+  // -- OfficeDocument core --
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/math",
+    "http://schemas.openxmlformats.org/officeDocument/2006/math"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/bibliography",
+    "http://schemas.openxmlformats.org/officeDocument/2006/bibliography"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/custom-properties",
+    "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/extended-properties",
+    "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/docPropsVTypes",
+    "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
+  ],
+  // -- OfficeDocument document relationship --
+  // (Other OPC-defined relationship types - package/relationships,
+  // core-properties, digital-signature - are conformance-independent and
+  // intentionally omitted; see the module header.)
+  [
+    "http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
+  ],
+  // -- Schema Library --
+  [
+    "http://purl.oclc.org/ooxml/schemaLibrary/main",
+    "http://schemas.openxmlformats.org/schemaLibrary/2006/main"
+  ],
+  // -- Content-type descriptions (note the distinct transitional host) --
+  [
+    "http://purl.oclc.org/ooxml/descriptions/base",
+    "http://descriptions.openxmlformats.org/description/base"
+  ],
+  [
+    "http://purl.oclc.org/ooxml/descriptions/full",
+    "http://descriptions.openxmlformats.org/description/full"
+  ],
+  // -- SpreadsheetML (for embedded charts / workbooks) --
+  [
+    "http://purl.oclc.org/ooxml/spreadsheetml/main",
+    "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+  ],
+  // -- WordprocessingML (for embedded docs) --
+  [
+    "http://purl.oclc.org/ooxml/wordprocessingml/main",
+    "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  ]
+];
+new Map(NAMESPACE_PAIRS);
+new Map(
+  NAMESPACE_PAIRS.map(([strict, transitional]) => [transitional, strict])
+);
+
+// src/core/utils/smartart-constraint-values.ts
+/* @__PURE__ */ new Set([
+  "none",
+  "alignOff",
+  "begMarg",
+  "bendDist",
+  "begPad",
+  "b",
+  "bMarg",
+  "bOff",
+  "ctrX",
+  "ctrXOff",
+  "ctrY",
+  "ctrYOff",
+  "connDist",
+  "diam",
+  "endMarg",
+  "endPad",
+  "h",
+  "hArH",
+  "hOff",
+  "l",
+  "lMarg",
+  "lOff",
+  "r",
+  "rMarg",
+  "rOff",
+  "primFontSz",
+  "pyraAcctRatio",
+  "secFontSz",
+  "sibSp",
+  "secSibSp",
+  "sp",
+  "stemThick",
+  "t",
+  "tMarg",
+  "tOff",
+  ...Array.from({ length: 26 }, (_, index) => `user${String.fromCharCode(65 + index)}`),
+  "w",
+  "wArH",
+  "wOff"
+]);
+
+// src/core/utils/smartart-relayout.ts
+function relayoutSmartArt(smartArtData, containerWidth, containerHeight) {
+  if (!smartArtData.nodes || smartArtData.nodes.length === 0) {
+    return [];
+  }
+  const bounds = {
+    x: 0,
+    y: 0,
+    width: containerWidth,
+    height: containerHeight
   };
+  const engineShapes = computeSmartArtLayout(smartArtData, bounds);
+  if (engineShapes && engineShapes.length > 0) {
+    const layoutType = smartArtData.resolvedLayoutType ?? "list";
+    return layoutEngineShapesToDrawingShapes(engineShapes, smartArtData.nodes, layoutType);
+  }
+  return smartArtData.drawingShapes ?? [];
+}
+
+// src/converter/svg-chart-extended.ts
+var DEFAULT_COLORS = ["#4472C4", "#ED7D31", "#A5A5A5", "#FFC000", "#5B9BD5", "#70AD47"];
+function esc(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function renderFunnelChartSvg(element, x, y, width, height) {
+  const series = element.chartData?.series[0];
+  if (!series?.values.length) {
+    return "";
+  }
+  const values = series.values.map((value) => Math.max(value, 0));
+  const maximum = Math.max(...values, 1);
+  const stageHeight = height / values.length;
+  const widthFor = (value) => width * Math.max(value / maximum, 0.08);
+  return values.map((value, index) => {
+    const topWidth = widthFor(value);
+    const nextValue2 = values[index + 1] ?? value * 0.72;
+    const bottomWidth = widthFor(nextValue2);
+    const center = x + width / 2;
+    const top = y + index * stageHeight;
+    const bottom = top + Math.max(stageHeight - 1, 0.5);
+    const pointColor = series.dataPoints?.find((point) => point.idx === index)?.spPr?.fillColor;
+    const fill = pointColor ?? series.color ?? DEFAULT_COLORS[index % DEFAULT_COLORS.length];
+    const points = [
+      `${center - topWidth / 2},${top}`,
+      `${center + topWidth / 2},${top}`,
+      `${center + bottomWidth / 2},${bottom}`,
+      `${center - bottomWidth / 2},${bottom}`
+    ].join(" ");
+    return `<polygon data-chart-mark="funnel" data-chart-point="${index}" points="${points}" fill="${esc(fill)}" />`;
+  }).join("");
+}
+
+// src/converter/svg-rich-elements.ts
+function esc2(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function color(series, index) {
+  const palette = ["#4472C4", "#ED7D31", "#A5A5A5", "#FFC000", "#5B9BD5", "#70AD47"];
+  return series.color ?? palette[index % palette.length];
+}
+function chartValues(element) {
+  return element.chartData?.series.flatMap((series) => series.values).filter(Number.isFinite) ?? [];
+}
+function renderBars(element, x, y, w, h) {
+  const data = element.chartData;
+  const values = chartValues(element);
+  const min = Math.min(0, ...values);
+  const max = Math.max(0, ...values);
+  const span = max - min || 1;
+  const zeroY = y + max / span * h;
+  const categoryCount = Math.max(
+    data.categories.length,
+    ...data.series.map((s) => s.values.length),
+    1
+  );
+  const clusterWidth = w / categoryCount;
+  const barWidth = clusterWidth * 0.72 / Math.max(data.series.length, 1);
+  const parts = [`<line x1="${x}" y1="${zeroY}" x2="${x + w}" y2="${zeroY}" stroke="#666666" />`];
+  data.series.forEach((series, seriesIndex) => {
+    series.values.forEach((value, categoryIndex) => {
+      const valueY = y + (max - value) / span * h;
+      parts.push(
+        `<rect data-chart-mark="bar" x="${x + categoryIndex * clusterWidth + clusterWidth * 0.14 + seriesIndex * barWidth}" y="${Math.min(valueY, zeroY)}" width="${Math.max(barWidth - 1, 1)}" height="${Math.max(Math.abs(zeroY - valueY), 0.5)}" fill="${esc2(color(series, seriesIndex))}" />`
+      );
+    });
+  });
+  return parts.join("");
+}
+function renderLines(element, x, y, w, h) {
+  const data = element.chartData;
+  const values = chartValues(element);
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const span = max - min || 1;
+  return data.series.map((series, seriesIndex) => {
+    const denominator = Math.max(series.values.length - 1, 1);
+    const points = series.values.map((value, index) => `${x + index / denominator * w},${y + (max - value) / span * h}`).join(" ");
+    return `<polyline data-chart-mark="line" points="${points}" fill="none" stroke="${esc2(color(series, seriesIndex))}" stroke-width="2" />`;
+  }).join("");
+}
+function polar(cx, cy, radius, angle) {
+  const radians = (angle - 90) * Math.PI / 180;
+  return [cx + radius * Math.cos(radians), cy + radius * Math.sin(radians)];
+}
+function renderPie(element, x, y, w, h) {
+  const series = element.chartData.series[0];
+  if (!series) {
+    return "";
+  }
+  const values = series.values.map((value) => Math.max(value, 0));
+  const total = values.reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return "";
+  }
+  const cx = x + w / 2;
+  const cy = y + h / 2;
+  const radius = Math.max(Math.min(w, h) / 2, 1);
+  let angle = 0;
+  return values.map((value, index) => {
+    const sweep = value / total * 360;
+    const [sx, sy] = polar(cx, cy, radius, angle);
+    const [ex, ey] = polar(cx, cy, radius, angle + sweep);
+    const pointColor = series.dataPoints?.find((point) => point.idx === index)?.spPr?.fillColor;
+    const path = `<path data-chart-mark="slice" d="M ${cx} ${cy} L ${sx} ${sy} A ${radius} ${radius} 0 ${sweep > 180 ? 1 : 0} 1 ${ex} ${ey} Z" fill="${esc2(color({ ...series, color: pointColor ?? series.color }, index))}" />`;
+    angle += sweep;
+    return path;
+  }).join("");
+}
+function renderChartSvg(element) {
+  const data = element.chartData;
+  if (!data || data.series.length === 0 || chartValues(element).length === 0) {
+    return null;
+  }
+  const titleHeight = data.title ? Math.min(element.height * 0.16, 28) : 0;
+  const x = Math.max(element.width * 0.08, 8);
+  const y = titleHeight + Math.max(element.height * 0.06, 6);
+  const w = Math.max(element.width - x * 1.5, 1);
+  const h = Math.max(element.height - y - Math.max(element.height * 0.1, 10), 1);
+  const pie = data.chartType === "pie" || data.chartType === "pie3D" || data.chartType === "doughnut";
+  const line = data.chartType === "line" || data.chartType === "line3D" || data.chartType === "scatter";
+  const marks = data.chartType === "funnel" ? renderFunnelChartSvg(element, x, y, w, h) : pie ? renderPie(element, x, y, w, h) : line ? renderLines(element, x, y, w, h) : renderBars(element, x, y, w, h);
+  const title = data.title ? `<text x="${element.width / 2}" y="${Math.max(titleHeight * 0.75, 14)}" text-anchor="middle" font-family="Arial" font-size="14" fill="#222222">${esc2(data.title)}</text>` : "";
+  return `<g data-pptx-element="chart" data-chart-type="${esc2(data.chartType)}"><rect width="${element.width}" height="${element.height}" fill="#FFFFFF" />${title}${marks}</g>`;
+}
+function renderSmartArtShape(shape) {
+  const fill = esc2(shape.fillColor ?? "#4472C4");
+  const stroke = esc2(shape.strokeColor ?? "#FFFFFF");
+  const transform = shape.rotation ? ` transform="rotate(${shape.rotation} ${shape.x + shape.width / 2} ${shape.y + shape.height / 2})"` : "";
+  let geometry;
+  if (shape.shapeType === "ellipse") {
+    geometry = `<ellipse cx="${shape.x + shape.width / 2}" cy="${shape.y + shape.height / 2}" rx="${shape.width / 2}" ry="${shape.height / 2}" fill="${fill}" stroke="${stroke}" />`;
+  } else if (shape.shapeType === "diamond") {
+    geometry = `<polygon points="${shape.x + shape.width / 2},${shape.y} ${shape.x + shape.width},${shape.y + shape.height / 2} ${shape.x + shape.width / 2},${shape.y + shape.height} ${shape.x},${shape.y + shape.height / 2}" fill="${fill}" stroke="${stroke}" />`;
+  } else {
+    geometry = `<rect x="${shape.x}" y="${shape.y}" width="${shape.width}" height="${shape.height}" rx="${shape.shapeType === "roundRect" ? Math.min(shape.width, shape.height) * 0.12 : 0}" fill="${fill}" stroke="${stroke}" stroke-width="${shape.strokeWidth ?? 1}" />`;
+  }
+  const text = shape.text ? `<text x="${shape.x + shape.width / 2}" y="${shape.y + shape.height / 2}" text-anchor="middle" dominant-baseline="central" font-family="Arial" font-size="${shape.fontSize ?? 12}" fill="${esc2(shape.fontColor ?? "#FFFFFF")}">${esc2(shape.text)}</text>` : "";
+  return `<g data-smartart-shape="${esc2(shape.id)}"${transform}>${geometry}${text}</g>`;
+}
+function renderSmartArtSvg(element) {
+  const data = element.smartArtData;
+  if (!data) {
+    return null;
+  }
+  const shapes = data.drawingShapes?.length ? data.drawingShapes : relayoutSmartArt(data, element.width, element.height);
+  if (shapes.length === 0) {
+    return null;
+  }
+  const chrome = data.chrome;
+  const background = chrome?.backgroundColor ? `<rect width="${element.width}" height="${element.height}" fill="${esc2(chrome.backgroundColor)}" stroke="${esc2(chrome.outlineColor ?? "none")}" stroke-width="${chrome.outlineWidth ?? 0}" />` : "";
+  return `<g data-pptx-element="smartArt">${background}${shapes.map(renderSmartArtShape).join("")}</g>`;
+}
+function previewImage(source, kind, width, height) {
+  if (!source || !source.startsWith("data:image/")) {
+    return null;
+  }
+  return `<image data-pptx-element="${kind}" width="${width}" height="${height}" preserveAspectRatio="none" href="${esc2(source)}" />`;
+}
+function renderMediaPreviewSvg(element) {
+  return previewImage(element.posterFrameData, "media", element.width, element.height);
+}
+function renderOlePreviewSvg(element) {
+  return previewImage(
+    element.previewImageData ?? element.previewImage,
+    "ole",
+    element.width,
+    element.height
+  );
+}
+function renderModel3DPreviewSvg(element) {
+  return previewImage(
+    element.posterImage ?? element.svgData ?? element.imageData,
+    "model3d",
+    element.width,
+    element.height
+  );
+}
+function renderContentPartSvg(element) {
+  if (!element.inkStrokes?.length) {
+    return null;
+  }
+  const strokes = element.inkStrokes.map(
+    (stroke) => `<path data-content-part="ink" d="${esc2(stroke.path)}" fill="none" stroke="${esc2(stroke.color)}" stroke-width="${stroke.width}" stroke-opacity="${stroke.opacity}" stroke-linecap="round" stroke-linejoin="round" />`
+  ).join("");
+  return `<g data-pptx-element="contentPart">${strokes}</g>`;
+}
+function renderZoomPreviewSvg(element) {
+  return previewImage(element.svgData ?? element.imageData, "zoom", element.width, element.height);
 }
 
 // src/converter/SvgExporter.ts
@@ -3521,14 +5386,14 @@ function createRenderContext(slideIndex = 0) {
     filterCounter: 0
   };
 }
-function getOrCreateArrowMarker(ctx, color) {
-  const key = color;
+function getOrCreateArrowMarker(ctx, color2) {
+  const key = color2;
   const cached = ctx.markerCache.get(key);
   if (cached) {
     return cached;
   }
   const id = `arrow_${++ctx.markerIdCounter}`;
-  const svg = `<marker id="${id}" markerWidth="10" markerHeight="7" refX="10" refY="3.5" orient="auto" markerUnits="strokeWidth"><polygon points="0 0, 10 3.5, 0 7" fill="${escXml(color)}" /></marker>`;
+  const svg = `<marker id="${id}" markerWidth="10" markerHeight="7" refX="10" refY="3.5" orient="auto" markerUnits="strokeWidth"><polygon points="0 0, 10 3.5, 0 7" fill="${escXml(color2)}" /></marker>`;
   ctx.defs.push(svg);
   ctx.markerCache.set(key, id);
   return id;
@@ -3559,7 +5424,7 @@ function renderText(el, defaults) {
   const style = el.textStyle;
   const fontFamily = style?.fontFamily ?? defaults.defaultFontFamily;
   const fontSize = style?.fontSize ?? defaults.defaultFontSize;
-  const color = style?.color ?? "#000000";
+  const color2 = style?.color ?? "#000000";
   const align = style?.align ?? "left";
   let textAnchor = "start";
   let textX = 4;
@@ -3578,7 +5443,7 @@ function renderText(el, defaults) {
         "text-anchor": textAnchor,
         "font-family": fontFamily,
         "font-size": fontSize,
-        fill: color
+        fill: color2
       })}>`
     );
     let dy = fontSize * 1.2;
@@ -3605,7 +5470,7 @@ function renderText(el, defaults) {
       if (segStyle.fontSize && segStyle.fontSize !== fontSize) {
         segAttrs["font-size"] = segStyle.fontSize;
       }
-      if (segStyle.color && segStyle.color !== color) {
+      if (segStyle.color && segStyle.color !== color2) {
         segAttrs.fill = segStyle.color;
       }
       if (segStyle.bold) {
@@ -3632,7 +5497,7 @@ function renderText(el, defaults) {
       "text-anchor": textAnchor,
       "font-family": fontFamily,
       "font-size": fontSize,
-      fill: color,
+      fill: color2,
       "font-weight": bold ? "bold" : void 0,
       "font-style": italic ? "italic" : void 0
     })}>`
@@ -3821,8 +5686,8 @@ function renderGroup(el, defaults, ctx) {
     return "";
   }
   const parts = [];
-  for (const child of el.children) {
-    parts.push(renderElement(child, defaults, ctx));
+  for (const child2 of el.children) {
+    parts.push(renderElement(child2, defaults, ctx));
   }
   return parts.join("");
 }
@@ -3833,14 +5698,14 @@ function renderInk(el) {
   const parts = [];
   for (let i = 0; i < el.inkPaths.length; i++) {
     const path = el.inkPaths[i];
-    const color = el.inkColors?.[i] ?? "#000000";
+    const color2 = el.inkColors?.[i] ?? "#000000";
     const width = el.inkWidths?.[i] ?? 1;
     const opacity = el.inkOpacities?.[i];
     parts.push(
       `<path${attrs({
         d: path,
         fill: "none",
-        stroke: color,
+        stroke: color2,
         "stroke-width": width,
         "stroke-opacity": opacity,
         "stroke-linecap": "round"
@@ -3898,12 +5763,26 @@ function renderElement(el, defaults, ctx) {
       inner = renderInk(el);
       break;
     case "chart":
+      inner = renderChartSvg(el) ?? renderPlaceholder(el);
+      break;
     case "smartArt":
+      inner = renderSmartArtSvg(el) ?? renderPlaceholder(el);
+      break;
     case "ole":
+      inner = renderOlePreviewSvg(el) ?? renderPlaceholder(el);
+      break;
     case "media":
+      inner = renderMediaPreviewSvg(el) ?? renderPlaceholder(el);
+      break;
+    case "model3d":
+      inner = renderModel3DPreviewSvg(el) ?? renderPlaceholder(el);
+      break;
     case "contentPart":
+      inner = renderContentPartSvg(el) ?? renderPlaceholder(el);
+      break;
     case "zoom":
-    case "model3d":
+      inner = renderZoomPreviewSvg(el) ?? renderPlaceholder(el);
+      break;
     case "unknown":
       inner = renderPlaceholder(el);
       break;