pptx-react-viewer 3.10.0 → 3.11.0

package/dist/{chunk-2Q2NFPXA.js → chunk-LY5535CF.js}

@@ -32086,6 +32086,39 @@ var init_smartart_interpreter_fold_text = __esm({
     init_smartart_node_text_projection();
   }
 });
+function buildConnectorLabels(connections) {
+  if (!connections || connections.length === 0) {
+    return void 0;
+  }
+  const labels = /* @__PURE__ */ new Map();
+  for (const connection of connections) {
+    if (!connection.label) {
+      continue;
+    }
+    const isParentChildEdge = !connection.type || connection.type === "parOf";
+    if (isParentChildEdge) {
+      labels.set(`${connection.sourceId}>${connection.destId}`, connection.label);
+    }
+  }
+  return labels.size > 0 ? labels : void 0;
+}
+function buildChildOrder(connections) {
+  if (!connections || connections.length === 0) {
+    return void 0;
+  }
+  const order = /* @__PURE__ */ new Map();
+  for (const connection of connections) {
+    const isParentChildEdge = !connection.type || connection.type === "parOf";
+    if (isParentChildEdge && typeof connection.srcOrd === "number") {
+      order.set(connection.destId, connection.srcOrd);
+    }
+  }
+  return order.size > 0 ? order : void 0;
+}
+var init_smartart_layout_interpreter_connector_order = __esm({
+  "src/core/utils/smartart-layout-interpreter-connector-order.ts"() {
+  }
+});
 function topLevelSmartArtNodes(nodes) {
   const hasNestedChildren = nodes.some((n) => n.children !== void 0 && n.children.length > 0);
   if (hasNestedChildren) {
@@ -32098,16 +32131,22 @@ function smartArtDescendantsWithText(node, childrenOf) {
   const out = [];
   const walk2 = (current) => {
     for (const child262 of childrenOf.get(current.id) ?? []) {
-      if (child262.text.trim().length > 0) {
-        out.push(child262);
-      }
+      out.push(child262);
       walk2(child262);
     }
   };
   walk2(node);
-  return out;
+  let start = 0;
+  while (start < out.length && out[start].text.trim().length === 0) {
+    start++;
+  }
+  let end = out.length - 1;
+  while (end >= start && out[end].text.trim().length === 0) {
+    end--;
+  }
+  return out.slice(start, end + 1);
 }
-function smartArtChildrenOf(nodes) {
+function smartArtChildrenOf(nodes, connections) {
   const map = /* @__PURE__ */ new Map();
   for (const n of nodes) {
     if (n.children && n.children.length > 0) {
@@ -32121,10 +32160,24 @@ function smartArtChildrenOf(nodes) {
       }
     }
   }
+  const childOrder3 = connections ? buildChildOrder(connections) : void 0;
+  if (childOrder3) {
+    for (const [parentId, list] of map) {
+      if (list.length > 1 && list.some((child262) => childOrder3.has(child262.id))) {
+        map.set(
+          parentId,
+          list.map((node, originalIndex) => ({ node, originalIndex })).sort(
+            (a, b) => (childOrder3.get(a.node.id) ?? a.originalIndex) - (childOrder3.get(b.node.id) ?? b.originalIndex)
+          ).map((entry2) => entry2.node)
+        );
+      }
+    }
+  }
   return map;
 }
 var init_smartart_node_tree_axis = __esm({
   "src/core/utils/smartart-node-tree-axis.ts"() {
+    init_smartart_layout_interpreter_connector_order();
   }
 });
 function polygonBoundingBox(points4) {
@@ -32137,9 +32190,9 @@ function polygonBoundingBox(points4) {
   const maxY = Math.max(...ys);
   return { x: minX, y: minY, width: Math.max(1, maxX - minX), height: Math.max(1, maxY - minY) };
 }
-function interpretedLayoutToElements(result, nodes, containerBounds, bulletEnabled = false) {
+function interpretedLayoutToElements(result, nodes, containerBounds, bulletEnabled = false, connections) {
   const nodeById = new Map(nodes.map((n) => [n.id, n]));
-  const childrenOf = smartArtChildrenOf(nodes);
+  const childrenOf = smartArtChildrenOf(nodes, connections);
   const renderedIds = new Set(
     result.nodes.flatMap((r) => [r.nodeId, ...r.foldedNodeIds ?? []]).filter((id) => Boolean(id))
   );
@@ -32365,39 +32418,6 @@ var init_smartart_hierarchy_child_order = __esm({
   "src/core/utils/smartart-hierarchy-child-order.ts"() {
   }
 });
-function buildConnectorLabels(connections) {
-  if (!connections || connections.length === 0) {
-    return void 0;
-  }
-  const labels = /* @__PURE__ */ new Map();
-  for (const connection of connections) {
-    if (!connection.label) {
-      continue;
-    }
-    const isParentChildEdge = !connection.type || connection.type === "parOf";
-    if (isParentChildEdge) {
-      labels.set(`${connection.sourceId}>${connection.destId}`, connection.label);
-    }
-  }
-  return labels.size > 0 ? labels : void 0;
-}
-function buildChildOrder(connections) {
-  if (!connections || connections.length === 0) {
-    return void 0;
-  }
-  const order = /* @__PURE__ */ new Map();
-  for (const connection of connections) {
-    const isParentChildEdge = !connection.type || connection.type === "parOf";
-    if (isParentChildEdge && typeof connection.srcOrd === "number") {
-      order.set(connection.destId, connection.srcOrd);
-    }
-  }
-  return order.size > 0 ? order : void 0;
-}
-var init_smartart_layout_interpreter_connector_order = __esm({
-  "src/core/utils/smartart-layout-interpreter-connector-order.ts"() {
-  }
-});
 function parsePoints(points4) {
   return points4.trim().split(/\s+/u).filter((pair) => pair.length > 0).map((pair) => {
     const [x, y] = pair.split(",").map(Number);
@@ -32508,163 +32528,6 @@ var init_smartart_layout_interpreter_custom = __esm({
   "src/core/utils/smartart-layout-interpreter-custom.ts"() {
   }
 });
-function arrowHeadPath(tipX, tipY, ux, uy) {
-  const bx = tipX - ux * ARROW_HEAD;
-  const by = tipY - uy * ARROW_HEAD;
-  const px3 = -uy;
-  const py = ux;
-  const w1x = bx + px3 * ARROW_WING;
-  const w1y = by + py * ARROW_WING;
-  const w2x = bx - px3 * ARROW_WING;
-  const w2y = by - py * ARROW_WING;
-  return ` M${w1x},${w1y} L${tipX},${tipY} L${w2x},${w2y}`;
-}
-function endHeads(x0, y0, x1, y1, begSty, endSty) {
-  const dx = x1 - x0;
-  const dy = y1 - y0;
-  const len = Math.hypot(dx, dy);
-  if (len < 1e-6) {
-    return "";
-  }
-  const ux = dx / len;
-  const uy = dy / len;
-  let heads = "";
-  if (endSty === "arr") {
-    heads += arrowHeadPath(x1, y1, ux, uy);
-  }
-  if (begSty === "arr") {
-    heads += arrowHeadPath(x0, y0, -ux, -uy);
-  }
-  return heads;
-}
-function straightPath(x0, y0, x1, y1) {
-  return `M${x0},${y0} L${x1},${y1}`;
-}
-function elbowPath(x0, y0, x1, y1) {
-  if (Math.abs(x1 - x0) >= Math.abs(y1 - y0)) {
-    const midX = (x0 + x1) / 2;
-    return `M${x0},${y0} L${midX},${y0} L${midX},${y1} L${x1},${y1}`;
-  }
-  const midY = (y0 + y1) / 2;
-  return `M${x0},${y0} L${x0},${midY} L${x1},${midY} L${x1},${y1}`;
-}
-function curvePath(x0, y0, x1, y1, centre) {
-  const midX = (x0 + x1) / 2;
-  const midY = (y0 + y1) / 2;
-  const pull = 1 + 30 / Math.max(1, Math.hypot(midX - centre.x, midY - centre.y));
-  const controlX = centre.x + (midX - centre.x) * pull;
-  const controlY = centre.y + (midY - centre.y) * pull;
-  return `M${x0},${y0} Q${controlX},${controlY} ${x1},${y1}`;
-}
-function connectorPath(x0, y0, x1, y1, centre, routing, begSty, endSty) {
-  const body = routing === "bend" ? elbowPath(x0, y0, x1, y1) : routing === "curve" ? curvePath(x0, y0, x1, y1, centre) : straightPath(x0, y0, x1, y1);
-  return body + endHeads(x0, y0, x1, y1, begSty, endSty);
-}
-function connectorEndpoints(from, to, horizontal, dim) {
-  const fromCx = from.x + from.width / 2;
-  const fromCy = from.y + from.height / 2;
-  const toCx = to.x + to.width / 2;
-  const toCy = to.y + to.height / 2;
-  if (dim === "2D") {
-    return { x0: fromCx, y0: fromCy, x1: toCx, y1: toCy };
-  }
-  if (horizontal) {
-    const leftFirst = fromCx <= toCx;
-    return leftFirst ? { x0: from.x + from.width, y0: fromCy, x1: to.x, y1: toCy } : { x0: from.x, y0: fromCy, x1: to.x + to.width, y1: toCy };
-  }
-  const topFirst = fromCy <= toCy;
-  return topFirst ? { x0: fromCx, y0: from.y + from.height, x1: toCx, y1: to.y } : { x0: fromCx, y0: from.y, x1: toCx, y1: to.y + to.height };
-}
-var ARROW_WING;
-var ARROW_HEAD;
-var init_smartart_layout_interpreter_conn_path = __esm({
-  "src/core/utils/smartart-layout-interpreter-conn-path.ts"() {
-    ARROW_WING = 4;
-    ARROW_HEAD = 7;
-  }
-});
-function resolveConstraintDeclaredBy(index, role, type, declaringRole) {
-  const candidates = index.entries.get(entryKey(role, type));
-  const fromArranger = candidates?.filter(
-    (c) => c.declaringRole === declaringRole
-  );
-  if (!fromArranger || fromArranger.length === 0) {
-    return void 0;
-  }
-  const visiting = /* @__PURE__ */ new Set([entryKey(role, type)]);
-  for (const candidate of fromArranger) {
-    const value = resolveEntry(index, candidate, visiting);
-    if (value !== void 0) {
-      return value;
-    }
-  }
-  return void 0;
-}
-function firstConstraintDeclaredBy(index, role, type, declaringRole) {
-  const candidates = index.entries.get(entryKey(role, type));
-  return candidates?.find((candidate) => candidate.declaringRole === declaringRole)?.constraint;
-}
-var init_smartart_constraint_declared_by = __esm({
-  "src/core/utils/smartart-constraint-declared-by.ts"() {
-    init_smartart_constraint_solver();
-  }
-});
-function isTransitionOnlyChild(node) {
-  const origin = node.forEachOrigin;
-  if (!origin) {
-    return false;
-  }
-  if (origin.axis?.includes("followSib") || origin.axis?.includes("follow")) {
-    return true;
-  }
-  const pointTypes = origin.pointTypes;
-  return (pointTypes?.length ?? 0) > 0 && (pointTypes?.every((type) => type === "sibTrans" || type === "parTrans") ?? false);
-}
-function isContinuationForEach(node) {
-  const forEach = node.forEach ?? [];
-  if (forEach.length === 0) {
-    return false;
-  }
-  return forEach.every(
-    (each) => each.axis?.length === 1 && each.axis[0] === "ch" && (each.start?.[0] ?? 1) > 1
-  );
-}
-function hasStructuralDescendant(node) {
-  return (node.children ?? []).some(
-    (child262) => STRUCTURAL_ALG_TYPES.has(child262.algorithm?.type ?? "") && !isContinuationForEach(child262) || hasStructuralDescendant(child262)
-  );
-}
-function mapsSlots(node) {
-  const declaredByArranger = (node.allConstraints ?? node.constraints ?? []).some(
-    (constraint) => constraint.for === "ch" && SLOT_CONSTRAINTS.has(constraint.type)
-  );
-  if (declaredByArranger) {
-    return true;
-  }
-  return (node.children ?? []).some(
-    (child262) => (child262.constraints ?? []).some((constraint) => SLOT_CONSTRAINTS.has(constraint.type))
-  );
-}
-function itemTemplateNodes(node, out) {
-  const drivesPoints = node.forEach?.some(
-    (each) => each.axis?.length === 1 && each.axis[0] === "ch" && (!each.pointTypes || each.pointTypes.includes("node"))
-  );
-  const item = node.children?.[0];
-  if (drivesPoints && item) {
-    out.add(item);
-  }
-  for (const child262 of node.children ?? []) {
-    itemTemplateNodes(child262, out);
-  }
-}
-var SLOT_CONSTRAINTS;
-var STRUCTURAL_ALG_TYPES;
-var init_smartart_layout_interpreter_composite_detect = __esm({
-  "src/core/utils/smartart-layout-interpreter-composite-detect.ts"() {
-    SLOT_CONSTRAINTS = /* @__PURE__ */ new Set(["l", "t", "w", "h", "ctrX", "ctrY"]);
-    STRUCTURAL_ALG_TYPES = /* @__PURE__ */ new Set(["lin", "cycle", "pyra", "snake", "hierRoot", "hierChild"]);
-  }
-});
 function children2(node, name, localName28) {
   const key2 = Object.keys(node).find((candidate) => localName28(candidate) === name);
   const value = key2 ? node[key2] : void 0;
@@ -32974,11 +32837,19 @@ function selectRange(nodes, start, count) {
   const take = count !== void 0 && count > 0 ? count : nodes.length - zeroBasedStart;
   return nodes.slice(zeroBasedStart, zeroBasedStart + take);
 }
+function applyPointTypeAndRange(nodes, pointType2, start, count) {
+  const filtered = pointType2 ? nodes.filter((n) => pointTypeMatches(n, pointType2)) : nodes;
+  return selectRange(filtered, start, count);
+}
 function resolveAxisNodes(nodes, axis, pointTypes, start, count, context) {
   if (axis.length === 0) {
     return void 0;
   }
-  if (context === void 0 && axis[0] !== "ch" && axis[0] !== "self") {
+  const rootRelative = context === void 0;
+  if (rootRelative && axis[0] !== "ch" && axis[0] !== "self" && axis[0] !== "root") {
+    return void 0;
+  }
+  if (rootRelative && axis[0] === "root" && axis.length > 1 && axis[1] !== "ch") {
     return void 0;
   }
   const byId = new Map(nodes.map((n) => [n.id, n]));
@@ -32997,16 +32868,30 @@ function resolveAxisNodes(nodes, axis, pointTypes, start, count, context) {
     }
   }
   const roots = nodes.filter((n) => !n.parentId || !byId.has(n.parentId));
-  let current = context !== void 0 ? navigateAxisHop(context, axis[0], nodes, childrenOf, parentOf, roots) : roots;
-  for (let hop = 0; hop < axis.length; hop += 1) {
-    if (hop > 0) {
-      current = navigateAxisHop(current, axis[hop], nodes, childrenOf, parentOf, roots);
-    }
-    const pointType2 = pointTypes?.[hop];
-    if (pointType2) {
-      current = current.filter((n) => pointTypeMatches(n, pointType2));
-    }
-    current = selectRange(current, start?.[hop], count?.[hop]);
+  let current;
+  let nextHop;
+  if (context !== void 0) {
+    current = applyPointTypeAndRange(
+      navigateAxisHop(context, axis[0], nodes, childrenOf, parentOf, roots),
+      pointTypes?.[0],
+      start?.[0],
+      count?.[0]
+    );
+    nextHop = 1;
+  } else if (axis[0] === "root" && axis.length > 1) {
+    current = applyPointTypeAndRange(roots, pointTypes?.[1], start?.[1], count?.[1]);
+    nextHop = 2;
+  } else {
+    current = applyPointTypeAndRange(roots, pointTypes?.[0], start?.[0], count?.[0]);
+    nextHop = 1;
+  }
+  for (let hop = nextHop; hop < axis.length; hop += 1) {
+    current = applyPointTypeAndRange(
+      navigateAxisHop(current, axis[hop], nodes, childrenOf, parentOf, roots),
+      pointTypes?.[hop],
+      start?.[hop],
+      count?.[hop]
+    );
   }
   return current;
 }
@@ -33201,14 +33086,178 @@ var init_smartart_layout_interpreter_choose_branch = __esm({
     localName6 = (key2) => key2.split(":").pop() ?? key2;
   }
 });
-function boundedCompositeAlg(raw, nodeCount, context) {
-  if (!raw) {
-    return void 0;
+function isTransitionOnlyChild(node) {
+  const origin = node.forEachOrigin;
+  if (!origin) {
+    return false;
   }
-  let found;
-  const visit = (value) => {
-    if (found !== void 0 || !value || typeof value !== "object") {
-      return;
+  if (origin.axis?.includes("followSib") || origin.axis?.includes("follow")) {
+    return true;
+  }
+  const pointTypes = origin.pointTypes;
+  return (pointTypes?.length ?? 0) > 0 && (pointTypes?.every((type) => type === "sibTrans" || type === "parTrans") ?? false);
+}
+function isContinuationForEach(node) {
+  const forEach = node.forEach ?? [];
+  if (forEach.length === 0) {
+    return false;
+  }
+  return forEach.every(
+    (each) => each.axis?.length === 1 && each.axis[0] === "ch" && (each.start?.[0] ?? 1) > 1
+  );
+}
+function hasStructuralDescendant(node) {
+  return (node.children ?? []).some(
+    (child262) => STRUCTURAL_ALG_TYPES.has(child262.algorithm?.type ?? "") && !isContinuationForEach(child262) || hasStructuralDescendant(child262)
+  );
+}
+function mapsSlots(node) {
+  const declaredByArranger = (node.allConstraints ?? node.constraints ?? []).some(
+    (constraint) => constraint.for === "ch" && SLOT_CONSTRAINTS.has(constraint.type)
+  );
+  if (declaredByArranger) {
+    return true;
+  }
+  return (node.children ?? []).some(
+    (child262) => (child262.constraints ?? []).some((constraint) => SLOT_CONSTRAINTS.has(constraint.type))
+  );
+}
+function itemTemplateNodes(node, out) {
+  const drivesPoints = node.forEach?.some(
+    (each) => each.axis?.length === 1 && each.axis[0] === "ch" && (!each.pointTypes || each.pointTypes.includes("node"))
+  );
+  const item = node.children?.[0];
+  if (drivesPoints && item) {
+    out.add(item);
+  }
+  for (const child262 of node.children ?? []) {
+    itemTemplateNodes(child262, out);
+  }
+}
+function isLayoutNodeOrDescendantOf(ancestor, node) {
+  if (ancestor === node) {
+    return true;
+  }
+  return (ancestor.children ?? []).some((child262) => isLayoutNodeOrDescendantOf(child262, node));
+}
+var SLOT_CONSTRAINTS;
+var STRUCTURAL_ALG_TYPES;
+var init_smartart_layout_interpreter_composite_detect = __esm({
+  "src/core/utils/smartart-layout-interpreter-composite-detect.ts"() {
+    SLOT_CONSTRAINTS = /* @__PURE__ */ new Set(["l", "t", "w", "h", "ctrX", "ctrY"]);
+    STRUCTURAL_ALG_TYPES = /* @__PURE__ */ new Set(["lin", "cycle", "pyra", "snake", "hierRoot", "hierChild"]);
+  }
+});
+function findStructuralAlgDepth(raw, crossedNames, nodeCount, context) {
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      const found = findStructuralAlgDepth(item, crossedNames, nodeCount, context);
+      if (found) {
+        return found;
+      }
+    }
+    return void 0;
+  }
+  for (const [key2, entry2] of Object.entries(raw)) {
+    if (key2.startsWith("@_")) {
+      continue;
+    }
+    const name = localName6(key2);
+    if (name === "alg") {
+      for (const candidate of Array.isArray(entry2) ? entry2 : [entry2]) {
+        const type = candidate && typeof candidate === "object" ? String(candidate["@_type"] ?? "") : "";
+        if (STRUCTURAL_CHOOSE_ALG_TYPES.has(type)) {
+          return { depth: crossedNames.length, crossedNames: [...crossedNames] };
+        }
+      }
+    } else if (name === "layoutNode") {
+      for (const candidate of Array.isArray(entry2) ? entry2 : [entry2]) {
+        if (!candidate || typeof candidate !== "object") {
+          continue;
+        }
+        const crossedName = String(candidate["@_name"] ?? "");
+        const found = findStructuralAlgDepth(
+          candidate,
+          [...crossedNames, crossedName],
+          nodeCount,
+          context
+        );
+        if (found) {
+          return found;
+        }
+      }
+    } else if (name === "choose") {
+      for (const candidate of Array.isArray(entry2) ? entry2 : [entry2]) {
+        if (!candidate || typeof candidate !== "object") {
+          continue;
+        }
+        const winningBranch = nestedChooseBranch(candidate, nodeCount, context);
+        if (winningBranch) {
+          const found = findStructuralAlgDepth(winningBranch, crossedNames, nodeCount, context);
+          if (found) {
+            return found;
+          }
+        }
+      }
+    } else if (entry2 && typeof entry2 === "object") {
+      const found = findStructuralAlgDepth(entry2, crossedNames, nodeCount, context);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return void 0;
+}
+function structuralChooseAlgDepth(node, nodeCount, context) {
+  if (!node.choose || node.choose.length === 0) {
+    return void 0;
+  }
+  for (const choose of node.choose) {
+    const branch = activeBranch(choose, nodeCount, context);
+    if (branch === void 0) {
+      continue;
+    }
+    const found = findStructuralAlgDepth(branch, [], nodeCount, context);
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+function tunnelsPastOwnCompositeSlot(node, nodeCount, context, itemTemplates) {
+  const looksLikeOwnComposite = node.algorithm?.type === "composite" && !itemTemplates.has(node) && !hasStructuralDescendant(node) && mapsSlots(node);
+  if (!looksLikeOwnComposite) {
+    return false;
+  }
+  const found = structuralChooseAlgDepth(node, nodeCount, context);
+  return found !== void 0 && found.depth >= 2;
+}
+var STRUCTURAL_CHOOSE_ALG_TYPES;
+var init_smartart_layout_interpreter_choose_depth = __esm({
+  "src/core/utils/smartart-layout-interpreter-choose-depth.ts"() {
+    init_smartart_layout_interpreter_choose_branch();
+    init_smartart_layout_interpreter_composite_detect();
+    STRUCTURAL_CHOOSE_ALG_TYPES = /* @__PURE__ */ new Set([
+      "lin",
+      "cycle",
+      "pyra",
+      "snake",
+      "hierChild",
+      "hierRoot"
+    ]);
+  }
+});
+function boundedCompositeAlg(raw, nodeCount, context) {
+  if (!raw) {
+    return void 0;
+  }
+  let found;
+  const visit = (value) => {
+    if (found !== void 0 || !value || typeof value !== "object") {
+      return;
     }
     if (Array.isArray(value)) {
       value.forEach(visit);
@@ -33434,6 +33483,13 @@ var init_smartart_layout_interpreter_flow = __esm({
     NODE_POINT_TYPES = /* @__PURE__ */ new Set(["node", "norm", "nonNorm", "asst", "nonAsst", "doc", "all"]);
   }
 });
+function hasPositionGuard(node) {
+  return node.chooseGuard?.some((guard) => guard.function === "pos") ?? false;
+}
+var init_smartart_layout_interpreter_position_family = __esm({
+  "src/core/utils/smartart-layout-interpreter-position-family.ts"() {
+  }
+});
 function walkWithTreeLocation(node, visit, location = { position: 1, total: 1, depth: 0 }) {
   visit(node, location);
   const children12 = node.children ?? [];
@@ -33497,6 +33553,33 @@ var init_smartart_layout_interpreter_constraints = __esm({
   "src/core/utils/smartart-layout-interpreter-constraints.ts"() {
   }
 });
+function itemNode(arranger) {
+  return arranger.children?.[0];
+}
+function algorithmParam(node, type) {
+  return node.algorithm?.parameters?.find((param) => param.type === type)?.value;
+}
+function numericParam(node, type, fallback) {
+  const raw = algorithmParam(node, type);
+  if (raw === void 0) {
+    return fallback;
+  }
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function resolveFlowDirection(arranger, presLayoutVars) {
+  const linDir = algorithmParam(arranger, "linDir");
+  const vertical = linDir === "fromT" || linDir === "fromB";
+  let reverse = linDir === "fromR" || linDir === "fromB";
+  if (presLayoutVars?.direction === "rev") {
+    reverse = !reverse;
+  }
+  return { orientation: vertical ? "vertical" : "horizontal", reverse };
+}
+var init_smartart_layout_interpreter_flow_direction = __esm({
+  "src/core/utils/smartart-layout-interpreter-flow-direction.ts"() {
+  }
+});
 function isMeaningfulAux(node) {
   return (node.constraints?.length ?? 0) > 0 || (node.children?.length ?? 0) > 0;
 }
@@ -33509,26 +33592,38 @@ function discoverArrangement(definition, nodeCount, presLayoutVars, flatNodes) {
   const maxDepth = treeMaxDepth(definition.rootNode);
   const itemTemplates = /* @__PURE__ */ new Set();
   itemTemplateNodes(definition.rootNode, itemTemplates);
+  const blockedSubtreeRoots = [];
   walkWithTreeLocation(definition.rootNode, (node, location) => {
-    if (!hierarchy && !chosen && nodeCount !== void 0 && node.choose && node.choose.length > 0 && !isContinuationForEach(node)) {
-      const resolvedAlg = chooseAlgorithm(node, nodeCount, {
+    if (!hierarchy && !chosen && nodeCount !== void 0 && node.choose && node.choose.length > 0 && !isContinuationForEach(node) && !blockedSubtreeRoots.some((root) => isLayoutNodeOrDescendantOf(root, node))) {
+      const whenContext = {
         presLayoutVars,
         position: location.position,
         total: location.total,
         depth: location.depth,
         maxDepth,
         nodes: flatNodes
-      });
+      };
+      const resolvedAlg = chooseAlgorithm(node, nodeCount, whenContext);
       const type2 = resolvedAlg?.type;
       if (type2 === "hierRoot" || type2 === "hierChild") {
         hierarchy = node.children?.find((child262) => child262.algorithm?.type === type2) ?? node;
       } else {
         const withResolvedAlg = resolvedAlg ? { ...node, algorithm: resolvedAlg } : node;
         const kind2 = type2 ? PRIMARY_ALG[type2] : void 0;
-        const arranger = node.children?.find(
+        const rawArranger = node.children?.find(
           (child262) => child262.algorithm?.type === type2 && !isTransitionOnlyChild(child262) && !isContinuationForEach(child262)
-        ) ?? withResolvedAlg;
-        if (kind2 && STRUCTURAL_ARRANGEMENT_KINDS.has(kind2)) {
+        );
+        const arranger = rawArranger && !hasPositionGuard(rawArranger) ? rawArranger : withResolvedAlg;
+        const tunnelledPastOwnSlot = tunnelsPastOwnCompositeSlot(
+          node,
+          nodeCount,
+          whenContext,
+          itemTemplates
+        );
+        if (tunnelledPastOwnSlot) {
+          blockedSubtreeRoots.push(node);
+        }
+        if (kind2 && STRUCTURAL_ARRANGEMENT_KINDS.has(kind2) && !tunnelledPastOwnSlot) {
           chosen = { kind: kind2, node: arranger };
         } else if (kind2 === "composite" && !itemTemplates.has(arranger) && mapsSlots(arranger)) {
           chosen = { kind: kind2, node: arranger };
@@ -33553,101 +33648,400 @@ function discoverArrangement(definition, nodeCount, presLayoutVars, flatNodes) {
       }
       return;
     }
-    if (STRUCTURAL_ARRANGEMENT_KINDS.has(kind)) {
-      if (!isContinuationForEach(node)) {
-        structural ??= { kind, node };
-      }
-      return;
+    if (STRUCTURAL_ARRANGEMENT_KINDS.has(kind)) {
+      if (!isContinuationForEach(node)) {
+        structural ??= { kind, node };
+      }
+      return;
+    }
+    if (!aux && isMeaningfulAux(node)) {
+      aux = { kind, node };
+    }
+  });
+  if (hierarchy) {
+    return { kind: "hierarchy", node: hierarchy };
+  }
+  if (chosen) {
+    return chosen;
+  }
+  if (compositeSlot) {
+    return { kind: "composite", node: compositeSlot };
+  }
+  return structural ?? aux;
+}
+var PRIMARY_ALG;
+var STRUCTURAL_ARRANGEMENT_KINDS;
+var init_smartart_layout_interpreter_model = __esm({
+  "src/core/utils/smartart-layout-interpreter-model.ts"() {
+    init_smartart_layout_interpreter_choose_depth();
+    init_smartart_layout_interpreter_composite_detect();
+    init_smartart_layout_interpreter_flow();
+    init_smartart_layout_interpreter_position_family();
+    init_smartart_layout_interpreter_tree_location();
+    init_smartart_layout_interpreter_constraints();
+    init_smartart_layout_interpreter_position_family();
+    init_smartart_layout_interpreter_flow_direction();
+    PRIMARY_ALG = {
+      lin: "linear",
+      cycle: "cycle",
+      pyra: "pyramid",
+      snake: "snake",
+      composite: "composite",
+      conn: "conn",
+      sp: "spacer",
+      tx: "text"
+    };
+    STRUCTURAL_ARRANGEMENT_KINDS = /* @__PURE__ */ new Set([
+      "linear",
+      "cycle",
+      "pyramid",
+      "snake"
+    ]);
+  }
+});
+function resolveReferencedRatio(index, role, types, rules) {
+  for (const type of types) {
+    const candidates = index.entries.get(entryKey(role, type));
+    if (!candidates?.some((entry2) => hasReference(entry2.constraint))) {
+      continue;
+    }
+    const resolved = resolveConstraint(index, role, type);
+    if (resolved !== void 0) {
+      return clampByRules(resolved, rules, type);
+    }
+  }
+  return void 0;
+}
+function resolveRatioConstraint(constraints, index, role, types, fallback, rules) {
+  const literal = ratioConstraint(constraints, types, Number.NaN, rules);
+  if (!Number.isNaN(literal)) {
+    return literal;
+  }
+  const relative = resolveReferencedRatio(index, role, types, rules);
+  return relative ?? fallback;
+}
+var init_smartart_constraint_ratio_fallback = __esm({
+  "src/core/utils/smartart-constraint-ratio-fallback.ts"() {
+    init_smartart_constraint_solver();
+    init_smartart_layout_interpreter_model();
+  }
+});
+function resolveHubToNodeRatio(ringItem, arrangerConstraints) {
+  if (!ringItem?.name) {
+    return void 0;
+  }
+  const match = (arrangerConstraints ?? []).find(
+    (c) => c.type === "w" && c.forName === ringItem.name && c.referenceType === "w" && (c.factor === void 0 || typeof c.factor === "number" && c.factor > 0) && typeof c.referenceForName === "string"
+  );
+  if (!match) {
+    return void 0;
+  }
+  return { hubName: match.referenceForName, factor: match.factor ?? 1 };
+}
+function resolveHubGapRatio(itemName, hubRatio, arrangerConstraints) {
+  if (!hubRatio) {
+    return void 0;
+  }
+  const sp = (arrangerConstraints ?? []).find(
+    (c) => c.type === "sp" && typeof c.factor === "number" && typeof c.referenceForName === "string"
+  );
+  if (!sp || typeof sp.factor !== "number") {
+    return void 0;
+  }
+  if (sp.referenceForName === itemName) {
+    return sp.factor;
+  }
+  if (sp.referenceForName === hubRatio.hubName) {
+    return sp.factor / hubRatio.factor;
+  }
+  return void 0;
+}
+var init_smartart_layout_interpreter_cycle_hub_ratio = __esm({
+  "src/core/utils/smartart-layout-interpreter-cycle-hub-ratio.ts"() {
+  }
+});
+function deriveCompositeSelfChildLayout(item) {
+  if (!item || item.algorithm?.type !== "composite") {
+    return void 0;
+  }
+  const constraints = item.allConstraints ?? item.constraints ?? [];
+  for (const width of constraints) {
+    if (width.type !== "w" || width.for !== "ch" || !width.forName || width.referenceForName !== void 0 || typeof width.factor !== "number" || width.factor <= 0) {
+      continue;
+    }
+    const selfName = width.forName;
+    const isSelfSquare = constraints.some(
+      (c) => c.type === "h" && c.for === "ch" && c.forName === selfName && c.referenceType === "w" && c.referenceFor === "ch" && c.referenceForName === selfName
+    );
+    if (!isSelfSquare) {
+      continue;
+    }
+    const childLeft = constraints.find(
+      (c) => c.type === "l" && c.for === "ch" && c.forName !== void 0 && c.forName !== selfName && c.referenceType === "w" && c.referenceFor === "ch" && c.referenceForName === selfName && typeof c.factor === "number"
+    );
+    const childName = childLeft?.forName;
+    const childWidth = childName ? constraints.find(
+      (c) => c.type === "w" && c.for === "ch" && c.forName === childName && c.referenceForName === void 0 && typeof c.factor === "number"
+    ) : void 0;
+    return {
+      selfName,
+      selfWidthFactor: width.factor,
+      childName,
+      childLeftFactor: childLeft?.factor,
+      childWidthFactor: childWidth?.factor
+    };
+  }
+  return void 0;
+}
+function resolveGraphAspectRatio(item, index) {
+  if (!item) {
+    return void 0;
+  }
+  const role = roleOf(item);
+  const resolvedH = resolveConstraint(index, role, "h");
+  const resolvedW = resolveConstraint(index, role, "w");
+  if (resolvedH === void 0 || resolvedW === void 0 || resolvedW <= 0) {
+    return void 0;
+  }
+  return resolvedH / resolvedW;
+}
+var init_smartart_layout_interpreter_cycle_item_aspect = __esm({
+  "src/core/utils/smartart-layout-interpreter-cycle-item-aspect.ts"() {
+    init_smartart_constraint_solver();
+  }
+});
+function absoluteConstraintPoints(constraint) {
+  if (constraint === void 0 || constraint.factor !== void 0 || constraint.referenceType !== void 0 || typeof constraint.value !== "number" || !Number.isFinite(constraint.value) || constraint.value < 1) {
+    return void 0;
+  }
+  return constraint.value;
+}
+function resolveCycleConstraintNode(arrangerNode) {
+  if (arrangerNode.name === "cycle") {
+    return arrangerNode;
+  }
+  for (const child262 of arrangerNode.children ?? []) {
+    if (child262.name === "cycle") {
+      return child262;
+    }
+  }
+  return arrangerNode;
+}
+function resolveRingItemNode(constraintNode, arrangerConstraints) {
+  const sibSpName = (arrangerConstraints ?? []).find(
+    (c) => c.type === "sibSp" && typeof c.referenceForName === "string"
+  )?.referenceForName;
+  const named = sibSpName ? (constraintNode.children ?? []).find((child262) => child262.name === sibSpName) : void 0;
+  if (named?.forEachOrigin) {
+    return named;
+  }
+  const repeating = (constraintNode.children ?? []).find((child262) => child262.forEachOrigin);
+  return repeating ?? named ?? itemNode(constraintNode);
+}
+function resolveCycleRingParams(arrangerNode, index) {
+  const constraintNode = resolveCycleConstraintNode(arrangerNode);
+  const arrangerConstraints = constraintNode.allConstraints ?? constraintNode.constraints;
+  const item = resolveRingItemNode(constraintNode, arrangerConstraints);
+  const itemConstraints = item?.allConstraints ?? item?.constraints;
+  const literalHeightOverWidth = ratioConstraint(
+    itemConstraints ?? [],
+    ["h"],
+    Number.NaN,
+    item?.rules
+  );
+  const contentLayout = deriveCompositeSelfChildLayout(item);
+  const heightOverWidth = !Number.isNaN(literalHeightOverWidth) ? literalHeightOverWidth : resolveGraphAspectRatio(item, index) ?? resolveRatioConstraint(itemConstraints, index, roleOf(item), ["h"], 1, item?.rules);
+  const hubRatio = resolveHubToNodeRatio(item, arrangerConstraints);
+  const hubGapRatio = resolveHubGapRatio(item?.name, hubRatio, arrangerConstraints);
+  const absoluteHubGap = absoluteConstraintPoints(findConstraint(arrangerConstraints, "sp"));
+  const absolutePoints = absoluteConstraintPoints(findConstraint(arrangerConstraints, "sibSp"));
+  if (absolutePoints !== void 0) {
+    return {
+      minGapRatio: DEFAULT_MIN_GAP_RATIO,
+      heightOverWidth,
+      absoluteGapPx: absolutePoints * POINTS_TO_PIXELS,
+      hubRatio,
+      hubGapRatio,
+      absoluteHubGapPx: absoluteHubGap !== void 0 ? absoluteHubGap * POINTS_TO_PIXELS : void 0,
+      contentLayout
+    };
+  }
+  const minGapRatio = resolveRatioConstraint(
+    arrangerConstraints,
+    index,
+    roleOf(constraintNode),
+    ["sibSp"],
+    DEFAULT_MIN_GAP_RATIO,
+    constraintNode.rules
+  );
+  return {
+    minGapRatio: Math.max(DEFAULT_MIN_GAP_RATIO, minGapRatio),
+    heightOverWidth,
+    hubRatio,
+    absoluteHubGapPx: absoluteHubGap !== void 0 ? absoluteHubGap * POINTS_TO_PIXELS : void 0,
+    contentLayout,
+    hubGapRatio
+  };
+}
+var POINTS_TO_PIXELS;
+var DEFAULT_MIN_GAP_RATIO;
+var init_smartart_layout_interpreter_cycle_constraints = __esm({
+  "src/core/utils/smartart-layout-interpreter-cycle-constraints.ts"() {
+    init_smartart_constraint_ratio_fallback();
+    init_smartart_constraint_solver();
+    init_smartart_layout_interpreter_constraints();
+    init_smartart_layout_interpreter_cycle_hub_ratio();
+    init_smartart_layout_interpreter_cycle_item_aspect();
+    init_smartart_layout_interpreter_model();
+    init_smartart_layout_interpreter_cycle_hub_ratio();
+    POINTS_TO_PIXELS = 96 / 72;
+    DEFAULT_MIN_GAP_RATIO = 0.5;
+  }
+});
+function repositionCycleRingContent(result, contentLayout, flatNodes) {
+  if (!contentLayout?.childName || contentLayout.childLeftFactor === void 0 || contentLayout.childWidthFactor === void 0 || contentLayout.selfWidthFactor <= 0) {
+    return result;
+  }
+  const { selfName, childName, childLeftFactor, childWidthFactor, selfWidthFactor } = contentLayout;
+  const parentIdById = new Map(flatNodes.map((node) => [node.id, node.parentId]));
+  const selfByNodeId = /* @__PURE__ */ new Map();
+  for (const node of result.nodes) {
+    if (node.kind === "circle" && node.itemRoleName === selfName && node.nodeId) {
+      selfByNodeId.set(node.nodeId, node);
+    }
+  }
+  const nodes = result.nodes.map((rendered) => {
+    if (rendered.kind !== "circle" || rendered.itemRoleName !== childName || !rendered.nodeId) {
+      return rendered;
     }
-    if (!aux && isMeaningfulAux(node)) {
-      aux = { kind, node };
+    const parentId = parentIdById.get(rendered.nodeId);
+    const self = parentId ? selfByNodeId.get(parentId) : void 0;
+    if (!self) {
+      return rendered;
     }
+    const selfW = 2 * (self.rx ?? self.r);
+    const selfH = 2 * (self.ry ?? self.r);
+    const selfLeft = self.cx - selfW / 2;
+    const childW = childWidthFactor / selfWidthFactor * selfW;
+    const childLeft = selfLeft + childLeftFactor * selfW;
+    const cx = childLeft + childW / 2;
+    const cy = self.cy;
+    return {
+      ...rendered,
+      cx,
+      cy,
+      r: Math.min(childW, selfH) / 2,
+      rx: childW / 2,
+      ry: selfH / 2,
+      textX: cx,
+      textY: cy
+    };
   });
-  if (hierarchy) {
-    return { kind: "hierarchy", node: hierarchy };
+  return { ...result, nodes };
+}
+var init_smartart_layout_interpreter_cycle_ring_item = __esm({
+  "src/core/utils/smartart-layout-interpreter-cycle-ring-item.ts"() {
   }
-  if (chosen) {
-    return chosen;
+});
+function arrowHeadPath(tipX, tipY, ux, uy) {
+  const bx = tipX - ux * ARROW_HEAD;
+  const by = tipY - uy * ARROW_HEAD;
+  const px3 = -uy;
+  const py = ux;
+  const w1x = bx + px3 * ARROW_WING;
+  const w1y = by + py * ARROW_WING;
+  const w2x = bx - px3 * ARROW_WING;
+  const w2y = by - py * ARROW_WING;
+  return ` M${w1x},${w1y} L${tipX},${tipY} L${w2x},${w2y}`;
+}
+function endHeads(x0, y0, x1, y1, begSty, endSty) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const len = Math.hypot(dx, dy);
+  if (len < 1e-6) {
+    return "";
   }
-  if (compositeSlot) {
-    return { kind: "composite", node: compositeSlot };
+  const ux = dx / len;
+  const uy = dy / len;
+  let heads = "";
+  if (endSty === "arr") {
+    heads += arrowHeadPath(x1, y1, ux, uy);
   }
-  return structural ?? aux;
-}
-function itemNode(arranger) {
-  return arranger.children?.[0];
+  if (begSty === "arr") {
+    heads += arrowHeadPath(x0, y0, -ux, -uy);
+  }
+  return heads;
 }
-function algorithmParam(node, type) {
-  return node.algorithm?.parameters?.find((param) => param.type === type)?.value;
+function straightPath(x0, y0, x1, y1) {
+  return `M${x0},${y0} L${x1},${y1}`;
 }
-function numericParam(node, type, fallback) {
-  const raw = algorithmParam(node, type);
-  if (raw === void 0) {
-    return fallback;
+function elbowPath(x0, y0, x1, y1) {
+  if (Math.abs(x1 - x0) >= Math.abs(y1 - y0)) {
+    const midX = (x0 + x1) / 2;
+    return `M${x0},${y0} L${midX},${y0} L${midX},${y1} L${x1},${y1}`;
   }
-  const parsed = Number(raw);
-  return Number.isFinite(parsed) ? parsed : fallback;
+  const midY = (y0 + y1) / 2;
+  return `M${x0},${y0} L${x0},${midY} L${x1},${midY} L${x1},${y1}`;
 }
-function resolveFlowDirection(arranger, presLayoutVars) {
-  const linDir = algorithmParam(arranger, "linDir");
-  const vertical = linDir === "fromT" || linDir === "fromB";
-  let reverse = linDir === "fromR" || linDir === "fromB";
-  if (presLayoutVars?.direction === "rev") {
-    reverse = !reverse;
+function curvePath(x0, y0, x1, y1, centre) {
+  const midX = (x0 + x1) / 2;
+  const midY = (y0 + y1) / 2;
+  const pull = 1 + 30 / Math.max(1, Math.hypot(midX - centre.x, midY - centre.y));
+  const controlX = centre.x + (midX - centre.x) * pull;
+  const controlY = centre.y + (midY - centre.y) * pull;
+  return `M${x0},${y0} Q${controlX},${controlY} ${x1},${y1}`;
+}
+function connectorPath(x0, y0, x1, y1, centre, routing, begSty, endSty) {
+  const body = routing === "bend" ? elbowPath(x0, y0, x1, y1) : routing === "curve" ? curvePath(x0, y0, x1, y1, centre) : straightPath(x0, y0, x1, y1);
+  return body + endHeads(x0, y0, x1, y1, begSty, endSty);
+}
+function connectorEndpoints(from, to, horizontal, dim) {
+  const fromCx = from.x + from.width / 2;
+  const fromCy = from.y + from.height / 2;
+  const toCx = to.x + to.width / 2;
+  const toCy = to.y + to.height / 2;
+  if (dim === "2D") {
+    return { x0: fromCx, y0: fromCy, x1: toCx, y1: toCy };
   }
-  return { orientation: vertical ? "vertical" : "horizontal", reverse };
+  if (horizontal) {
+    const leftFirst = fromCx <= toCx;
+    return leftFirst ? { x0: from.x + from.width, y0: fromCy, x1: to.x, y1: toCy } : { x0: from.x, y0: fromCy, x1: to.x + to.width, y1: toCy };
+  }
+  const topFirst = fromCy <= toCy;
+  return topFirst ? { x0: fromCx, y0: from.y + from.height, x1: toCx, y1: to.y } : { x0: fromCx, y0: from.y, x1: toCx, y1: to.y + to.height };
 }
-var PRIMARY_ALG;
-var STRUCTURAL_ARRANGEMENT_KINDS;
-var init_smartart_layout_interpreter_model = __esm({
-  "src/core/utils/smartart-layout-interpreter-model.ts"() {
-    init_smartart_layout_interpreter_composite_detect();
-    init_smartart_layout_interpreter_flow();
-    init_smartart_layout_interpreter_tree_location();
-    init_smartart_layout_interpreter_constraints();
-    PRIMARY_ALG = {
-      lin: "linear",
-      cycle: "cycle",
-      pyra: "pyramid",
-      snake: "snake",
-      composite: "composite",
-      conn: "conn",
-      sp: "spacer",
-      tx: "text"
-    };
-    STRUCTURAL_ARRANGEMENT_KINDS = /* @__PURE__ */ new Set([
-      "linear",
-      "cycle",
-      "pyramid",
-      "snake"
-    ]);
+var ARROW_WING;
+var ARROW_HEAD;
+var init_smartart_layout_interpreter_conn_path = __esm({
+  "src/core/utils/smartart-layout-interpreter-conn-path.ts"() {
+    ARROW_WING = 4;
+    ARROW_HEAD = 7;
   }
 });
-function resolveReferencedRatio(index, role, types, rules) {
-  for (const type of types) {
-    const candidates = index.entries.get(entryKey(role, type));
-    if (!candidates?.some((entry2) => hasReference(entry2.constraint))) {
-      continue;
-    }
-    const resolved = resolveConstraint(index, role, type);
-    if (resolved !== void 0) {
-      return clampByRules(resolved, rules, type);
+function resolveConstraintDeclaredBy(index, role, type, declaringRole) {
+  const candidates = index.entries.get(entryKey(role, type));
+  const fromArranger = candidates?.filter(
+    (c) => c.declaringRole === declaringRole
+  );
+  if (!fromArranger || fromArranger.length === 0) {
+    return void 0;
+  }
+  const visiting = /* @__PURE__ */ new Set([entryKey(role, type)]);
+  for (const candidate of fromArranger) {
+    const value = resolveEntry(index, candidate, visiting);
+    if (value !== void 0) {
+      return value;
     }
   }
   return void 0;
 }
-function resolveRatioConstraint(constraints, index, role, types, fallback, rules) {
-  const literal = ratioConstraint(constraints, types, Number.NaN, rules);
-  if (!Number.isNaN(literal)) {
-    return literal;
-  }
-  const relative = resolveReferencedRatio(index, role, types, rules);
-  return relative ?? fallback;
+function firstConstraintDeclaredBy(index, role, type, declaringRole) {
+  const candidates = index.entries.get(entryKey(role, type));
+  return candidates?.find((candidate) => candidate.declaringRole === declaringRole)?.constraint;
 }
-var init_smartart_constraint_ratio_fallback = __esm({
-  "src/core/utils/smartart-constraint-ratio-fallback.ts"() {
+var init_smartart_constraint_declared_by = __esm({
+  "src/core/utils/smartart-constraint-declared-by.ts"() {
     init_smartart_constraint_solver();
-    init_smartart_layout_interpreter_model();
   }
 });
 var INSET;
@@ -33932,7 +34326,7 @@ function presetCornerRadiusFraction(shape) {
   }
   const raw = shape?.adjustments?.find((adjustment) => adjustment.index === 1)?.value;
   if (raw === void 0) {
-    return 0.15;
+    return DEFAULT_ROUND_RECT_ADJ_FRACTION;
   }
   return raw > 1 ? raw / 1e5 : raw;
 }
@@ -33946,6 +34340,7 @@ function roundRectCornerInsetPx(shape, widthPx, heightPx) {
 var CIRCLE_PRESETS;
 var POLYGON_PRESETS;
 var ROUND_RECT_PRESETS;
+var DEFAULT_ROUND_RECT_ADJ_FRACTION;
 var CORNER_ARC_INSET_FACTOR;
 var init_smartart_layout_shape_preset = __esm({
   "src/core/utils/smartart-layout-shape-preset.ts"() {
@@ -33973,6 +34368,7 @@ var init_smartart_layout_shape_preset = __esm({
       "snip2DiagRect",
       "snipRoundRect"
     ]);
+    DEFAULT_ROUND_RECT_ADJ_FRACTION = 16667 / 1e5;
     CORNER_ARC_INSET_FACTOR = 1 - Math.SQRT2 / 2;
   }
 });
@@ -34989,9 +35385,9 @@ function nodeFontBounds(fontRoleCandidate, arranger, index) {
   const fontRoleNode = findFontRoleNode(fontRoleCandidate) ?? fontRoleCandidate;
   const role = fontRoleNode ? roleOf(fontRoleNode) : roleOf(arranger);
   const declared = resolveConstraint(index, role, "primFontSz");
-  const ceilingPx = typeof declared === "number" && declared > 0 ? declared * POINTS_TO_PIXELS : DEFAULT_CEILING_PX;
+  const ceilingPx = typeof declared === "number" && declared > 0 ? declared * POINTS_TO_PIXELS2 : DEFAULT_CEILING_PX;
   const floorRuleValues = primFontSzFloorRuleValues(fontRoleNode, arranger, role);
-  const floorPx = floorRuleValues.length > 0 ? Math.min(...floorRuleValues) * POINTS_TO_PIXELS : DEFAULT_FLOOR_PX;
+  const floorPx = floorRuleValues.length > 0 ? Math.min(...floorRuleValues) * POINTS_TO_PIXELS2 : DEFAULT_FLOOR_PX;
   return { ceilingPx, floorPx: Math.min(floorPx, ceilingPx), role };
 }
 function itemFontBoundsPx(plan, index) {
@@ -35000,7 +35396,7 @@ function itemFontBoundsPx(plan, index) {
 function primFontSzCeilingPx(plan, index) {
   return itemFontBoundsPx(plan, index).ceilingPx;
 }
-var POINTS_TO_PIXELS;
+var POINTS_TO_PIXELS2;
 var DEFAULT_CEILING_PX;
 var DEFAULT_FLOOR_PX;
 var DECORATIVE_FONT_ALGORITHM_TYPES;
@@ -35008,7 +35404,7 @@ var init_smartart_layout_item_font_role = __esm({
   "src/core/utils/smartart-layout-item-font-role.ts"() {
     init_smartart_constraint_solver();
     init_smartart_layout_interpreter_model();
-    POINTS_TO_PIXELS = 96 / 72;
+    POINTS_TO_PIXELS2 = 96 / 72;
     DEFAULT_CEILING_PX = 12;
     DEFAULT_FLOOR_PX = 6;
     DECORATIVE_FONT_ALGORITHM_TYPES = /* @__PURE__ */ new Set(["sp", "composite", "conn"]);
@@ -35024,12 +35420,13 @@ function measureTextWidth(text22, fontSize, table) {
   }
   return widthPx;
 }
-function wrappedLineCount(text22, maxWidth, fontSize, table) {
+function greedyWrap(text22, maxWidth, fontSize, table) {
   if (maxWidth <= 0) {
-    return Number.POSITIVE_INFINITY;
+    return { lines: Number.POSITIVE_INFINITY, widestLineWidth: 0 };
   }
   const spaceWidth = measureTextWidth(" ", fontSize, table);
   let lines = 0;
+  let widestLineWidth = 0;
   for (const paragraph of text22.split("\n")) {
     const words = paragraph.split(/\s+/u).filter((word) => word.length > 0);
     if (words.length === 0) {
@@ -35042,15 +35439,23 @@ function wrappedLineCount(text22, maxWidth, fontSize, table) {
       const wordWidth = measureTextWidth(word, fontSize, table);
       const extended = lineWidth === 0 ? wordWidth : lineWidth + spaceWidth + wordWidth;
       if (extended > maxWidth && lineWidth > 0) {
+        widestLineWidth = Math.max(widestLineWidth, lineWidth);
         paragraphLines += 1;
         lineWidth = wordWidth;
       } else {
         lineWidth = extended;
       }
     }
+    widestLineWidth = Math.max(widestLineWidth, lineWidth);
     lines += paragraphLines;
   }
-  return Math.max(1, lines);
+  return { lines: Math.max(1, lines), widestLineWidth };
+}
+function wrappedLineCount(text22, maxWidth, fontSize, table) {
+  return greedyWrap(text22, maxWidth, fontSize, table).lines;
+}
+function wrappedWidestLineWidth(text22, maxWidth, fontSize, table) {
+  return greedyWrap(text22, maxWidth, fontSize, table).widestLineWidth;
 }
 function fitsAt(text22, maxWidth, maxHeight, size, table, lineSpacingFactor) {
   return wrappedLineCount(text22, maxWidth, size, table) * size * table.lineHeightRatio * lineSpacingFactor <= maxHeight;
@@ -35101,8 +35506,8 @@ function itemMarginsPx(index, role, table) {
   const topPt = typeof top === "number" ? top : table.marginTopPt;
   const bottomPt = typeof bottom === "number" ? bottom : table.marginBottomPt;
   return {
-    horizontal: (leftPt + rightPt) * POINTS_TO_PIXELS2,
-    vertical: (topPt + bottomPt) * POINTS_TO_PIXELS2
+    horizontal: (leftPt + rightPt) * POINTS_TO_PIXELS3,
+    vertical: (topPt + bottomPt) * POINTS_TO_PIXELS3
   };
 }
 function proportionalMarginFraction(index, role) {
@@ -35120,7 +35525,7 @@ function proportionalMarginFraction(index, role) {
   return { horizontal: (left ?? 0) + (right ?? 0), vertical: (top ?? 0) + (bottom ?? 0) };
 }
 function snapToWholePoint(sizePx2) {
-  return Math.round(sizePx2 / POINTS_TO_PIXELS2) * POINTS_TO_PIXELS2;
+  return Math.round(sizePx2 / POINTS_TO_PIXELS3) * POINTS_TO_PIXELS3;
 }
 function resolveRoleFontSize(roleNode, index, items, fontName) {
   return fitSharedFontSize(
@@ -35175,7 +35580,7 @@ function fitSharedFontSize(bounds, index, items, fontName, naturalAspect) {
   }
   return snapToWholePoint(shared);
 }
-var POINTS_TO_PIXELS2;
+var POINTS_TO_PIXELS3;
 var init_smartart_layout_item_font_size = __esm({
   "src/core/utils/smartart-layout-item-font-size.ts"() {
     init_font_advance_widths_generated();
@@ -35183,15 +35588,31 @@ var init_smartart_layout_item_font_size = __esm({
     init_smartart_layout_item_font_role();
     init_smartart_text_wrap_fit();
     init_smartart_layout_item_font_role();
-    POINTS_TO_PIXELS2 = 96 / 72;
+    POINTS_TO_PIXELS3 = 96 / 72;
   }
 });
+function extrapolatedIndentPt(descendantSizePt) {
+  const last = DESCENDANT_INDENT_STEPS_PT[DESCENDANT_INDENT_STEPS_PT.length - 1];
+  const tiersBeyond = Math.floor((descendantSizePt - last.maxSz - 1) / 13) + 1;
+  return last.indentPt + tiersBeyond * 4.5;
+}
+function descendantIndentPt(descendantSizePt) {
+  for (const step of DESCENDANT_INDENT_STEPS_PT) {
+    if (descendantSizePt <= step.maxSz) {
+      return step.indentPt;
+    }
+  }
+  return extrapolatedIndentPt(descendantSizePt);
+}
 function paragraphBlockPx(lines, sizePx2, ratio, lineSpacingFactor, spcAftFactor, isLastParagraph) {
   const content = lines * sizePx2 * ratio * lineSpacingFactor;
   return isLastParagraph ? content : content + spcAftFactor * sizePx2 * ratio;
 }
 function itemFits(item, availWidthPx, availHeightPx, rootPx, descendantPx, table, lineSpacingFactor) {
   const hasDescendants = item.descendantTexts.length > 0;
+  if (wrappedWidestLineWidth(item.rootText, availWidthPx, rootPx, table) > availWidthPx) {
+    return false;
+  }
   const rootLines = wrappedLineCount(item.rootText, availWidthPx, rootPx, table);
   let totalPx = paragraphBlockPx(
     rootLines,
@@ -35201,9 +35622,15 @@ function itemFits(item, availWidthPx, availHeightPx, rootPx, descendantPx, table
     ROOT_SPCAFT_FACTOR,
     !hasDescendants
   );
+  const descendantIndentPx = descendantIndentPt(descendantPx / PX_PER_PT) * PX_PER_PT;
+  const descendantWidthPx = Math.max(1, availWidthPx - descendantIndentPx);
   for (let i2 = 0; i2 < item.descendantTexts.length; i2++) {
     const isLast = i2 === item.descendantTexts.length - 1;
-    const lines = wrappedLineCount(item.descendantTexts[i2], availWidthPx, descendantPx, table);
+    const text22 = item.descendantTexts[i2];
+    if (wrappedWidestLineWidth(text22, descendantWidthPx, descendantPx, table) > descendantWidthPx) {
+      return false;
+    }
+    const lines = wrappedLineCount(text22, descendantWidthPx, descendantPx, table);
     totalPx += paragraphBlockPx(
       lines,
       descendantPx,
@@ -35217,11 +35644,21 @@ function itemFits(item, availWidthPx, availHeightPx, rootPx, descendantPx, table
 }
 var ROOT_SPCAFT_FACTOR;
 var DESCENDANT_SPCAFT_FACTOR;
+var PX_PER_PT;
+var DESCENDANT_INDENT_STEPS_PT;
 var init_smartart_layout_item_font_tier_fit = __esm({
   "src/core/utils/smartart-layout-item-font-tier-fit.ts"() {
     init_smartart_text_wrap_fit();
     ROOT_SPCAFT_FACTOR = 0.35;
     DESCENDANT_SPCAFT_FACTOR = 0.15;
+    PX_PER_PT = 96 / 72;
+    DESCENDANT_INDENT_STEPS_PT = [
+      { maxSz: 11, indentPt: 4.5 },
+      { maxSz: 15, indentPt: 9 },
+      { maxSz: 19, indentPt: 13.5 },
+      { maxSz: 27, indentPt: 18 },
+      { maxSz: 40, indentPt: 22.5 }
+    ];
   }
 });
 function resolveTieredItemFontSize(plan, index, items, fontName, naturalAspect, cornerInsetPx = 0) {
@@ -35232,7 +35669,7 @@ function resolveTieredItemFontSize(plan, index, items, fontName, naturalAspect,
   const table = resolveFontTable(fontName);
   const fixedMargins = itemMarginsPx(index, role, table);
   const proportional = proportionalMarginFraction(index, role);
-  const lineSpacingFactor = typeof naturalAspect === "number" ? 1 : SMARTART_LINE_SPACING_FACTOR;
+  const lineSpacingFactor = SMARTART_LINE_SPACING_FACTOR;
   const fitsAtMarginBasis = (rootPx2, marginBasisPx) => {
     const margins = proportional ? {
       horizontal: proportional.horizontal * marginBasisPx,
@@ -35241,8 +35678,7 @@ function resolveTieredItemFontSize(plan, index, items, fontName, naturalAspect,
     for (const item of items) {
       const naturalHeight = typeof naturalAspect === "number" ? Math.min(item.height, item.width * naturalAspect) : item.height;
       const availWidthPx = Math.max(1, item.width - margins.horizontal - 2 * cornerInsetPx);
-      const hasDescendants = item.descendantTexts.length > 0;
-      const verticalReduction = hasDescendants || cornerInsetPx === 0 ? margins.vertical + cornerInsetPx : 2 * cornerInsetPx;
+      const verticalReduction = margins.vertical + 2 * cornerInsetPx;
       const availHeightPx = Math.max(1, naturalHeight - verticalReduction);
       const descendantPx = rootPx2 * SMARTART_DESCENDANT_FONT_SCALE;
       const fits = itemFits(
@@ -35293,12 +35729,12 @@ function resolveTieredItemFontSize(plan, index, items, fontName, naturalAspect,
   }
   const rounded = snapToWholePoint(rootPx);
   const roundedUp = rounded > rootPx;
-  const rootSizePx = roundedUp && !fitsAtMarginBasis(rounded, rootPx) ? Math.floor(rootPx / PX_PER_PT) * PX_PER_PT : rounded;
+  const rootSizePx = roundedUp && !fitsAtMarginBasis(rounded, rootPx) ? Math.floor(rootPx / PX_PER_PT2) * PX_PER_PT2 : rounded;
   const descendantSizePx = snapToWholePoint(rootSizePx * SMARTART_DESCENDANT_FONT_SCALE);
   return { rootSizePx, descendantSizePx };
 }
 var SMARTART_DESCENDANT_FONT_SCALE;
-var PX_PER_PT;
+var PX_PER_PT2;
 var init_smartart_layout_item_font_tier = __esm({
   "src/core/utils/smartart-layout-item-font-tier.ts"() {
     init_smartart_layout_item_font_role();
@@ -35306,7 +35742,7 @@ var init_smartart_layout_item_font_tier = __esm({
     init_smartart_layout_item_font_tier_fit();
     init_smartart_text_wrap_fit();
     SMARTART_DESCENDANT_FONT_SCALE = 0.78;
-    PX_PER_PT = 96 / 72;
+    PX_PER_PT2 = 96 / 72;
   }
 });
 function snakeGridDims(plan, n, w, h2, flowDir) {
@@ -35542,14 +35978,17 @@ function arrangeLinear(plan, flow, nodes, box, palette, style, elementId, index
     n,
     clampRatio
   );
-  const crossExtent = aspect ? Math.min(usableCross, Math.max(12, mainExtent * aspect)) : usableCross;
-  const crossPos = INSET + (usableCross - crossExtent) / 2;
-  const start = INSET + begPad * mainExtent;
   const itemTemplate = itemNode(plan.node);
   const itemShape = findCompositeItemShape(itemTemplate);
+  const naturalAspect = resolveItemSelfAspect(itemTemplate);
+  const crossExtent = aspect ? Math.min(usableCross, Math.max(12, mainExtent * aspect)) : typeof naturalAspect === "number" ? Math.min(
+    usableCross,
+    Math.max(12, mainExtent * (horizontal ? naturalAspect : 1 / naturalAspect))
+  ) : usableCross;
+  const crossPos = INSET + (usableCross - crossExtent) / 2;
+  const start = INSET + begPad * mainExtent;
   const itemW = horizontal ? mainExtent : crossExtent;
   const itemH = horizontal ? crossExtent : mainExtent;
-  const naturalAspect = resolveItemSelfAspect(itemTemplate);
   const renderedIds = new Set(flow2.map((node) => node.id));
   const descendantTextsFor = (node) => childrenOf ? foldedDescendantTexts(node, renderedIds, childrenOf) : [];
   const naturalHeightForInset = typeof naturalAspect === "number" ? Math.min(itemH, itemW * naturalAspect) : itemH;
@@ -35933,50 +36372,70 @@ var init_smartart_layout_interpreter_composite_children = __esm({
     init_smartart_node_tree_axis();
   }
 });
+function resolveOrigin(node, flat) {
+  const origin = node.forEachOrigin;
+  if (!origin?.axis || origin.axis.length === 0) {
+    return [];
+  }
+  return resolveAxisNodes(flat, origin.axis, origin.pointTypes, origin.start, origin.count) ?? [];
+}
 function resolveAnchoredContent(node, flat) {
   const presOf = node.presentationOf;
   if (!presOf?.axis || presOf.axis.length === 0) {
     return [];
   }
-  const origin = node.forEachOrigin;
-  if (!origin?.axis || origin.axis.length === 0) {
+  const anchors = resolveOrigin(node, flat);
+  if (!node.forEachOrigin?.axis || node.forEachOrigin.axis.length === 0) {
     return resolveAxisNodes(flat, presOf.axis, presOf.pointTypes, presOf.start, presOf.count) ?? [];
   }
-  const anchors = resolveAxisNodes(flat, origin.axis, origin.pointTypes, origin.start, origin.count) ?? [];
   if (anchors.length === 0) {
     return [];
   }
   return resolveAxisNodes(flat, presOf.axis, presOf.pointTypes, presOf.start, presOf.count, anchors) ?? [];
 }
+function resolveAnchoredContentPerAnchor(node, flat) {
+  const presOf = node.presentationOf;
+  if (!presOf?.axis || presOf.axis.length === 0) {
+    return [];
+  }
+  if (!node.forEachOrigin?.axis || node.forEachOrigin.axis.length === 0) {
+    const content = resolveAnchoredContent(node, flat);
+    return content.length > 0 ? [content] : [];
+  }
+  const anchors = resolveOrigin(node, flat);
+  const groups = [];
+  for (const anchor of anchors) {
+    const content = resolveAxisNodes(flat, presOf.axis, presOf.pointTypes, presOf.start, presOf.count, [
+      anchor
+    ]) ?? [];
+    if (content.length > 0) {
+      groups.push(content);
+    }
+  }
+  return groups;
+}
 var init_smartart_layout_interpreter_composite_anchor = __esm({
   "src/core/utils/smartart-layout-interpreter-composite-anchor.ts"() {
     init_smartart_layout_interpreter_axis_count();
   }
 });
-function guardAllows(node, flat) {
-  if (!node.chooseGuard) {
-    return true;
+function resolveIterationRect(dims, box, iteration, iterationCount) {
+  const container = resolveSlot(dims, box, 1, 1);
+  if (iterationCount <= 1) {
+    return container;
   }
-  return evaluateWhen(node.chooseGuard, flat.length, { nodes: flat }) !== false;
-}
-function collectRawCandidates(node, flat, declaringRole, out = []) {
-  if (!guardAllows(node, flat)) {
-    return out;
-  }
-  const axis = node.presentationOf?.axis;
-  if (axis && axis.length > 0) {
-    const content = resolveAnchoredContent(node, flat);
-    if (content.length > 0) {
-      out.push({ node, declaringRole, content });
-    }
-    return out;
-  }
-  const nextRole = roleOf(node);
-  for (const child262 of node.children ?? []) {
-    collectRawCandidates(child262, flat, nextRole, out);
+  if (container.width >= container.height) {
+    const width = container.width / iterationCount;
+    return { x: container.x + width * iteration, y: container.y, width, height: container.height };
   }
-  return out;
+  const height = container.height / iterationCount;
+  return { x: container.x, y: container.y + height * iteration, width: container.width, height };
 }
+var init_smartart_layout_interpreter_composite_iteration = __esm({
+  "src/core/utils/smartart-layout-interpreter-composite-iteration.ts"() {
+    init_smartart_layout_interpreter_composite_slots();
+  }
+});
 function contentSignature(content) {
   return content.map((n) => n.id).sort().join(" ");
 }
@@ -36001,13 +36460,59 @@ function resolveGroupedSlots(candidates, box, index) {
     for (const candidate of ordered4) {
       const [slotted] = readSlots([candidate.node], box, index, candidate.declaringRole);
       if (slotted) {
-        out.push({ rect: resolveSlot(slotted.dims, box, 1, 1), content: candidate.content });
+        const rect22 = resolveIterationRect(
+          slotted.dims,
+          box,
+          candidate.iteration,
+          candidate.iterationCount
+        );
+        out.push({ rect: rect22, content: candidate.content });
         break;
       }
     }
   }
   return out;
 }
+var init_smartart_layout_interpreter_composite_group_slots = __esm({
+  "src/core/utils/smartart-layout-interpreter-composite-group-slots.ts"() {
+    init_smartart_layout_interpreter_composite_iteration();
+    init_smartart_layout_interpreter_composite_slots();
+  }
+});
+function guardAllows(node, flat, iterationPosition) {
+  if (!node.chooseGuard) {
+    return true;
+  }
+  return node.chooseGuard.every(
+    (guard) => evaluateWhen(guard, flat.length, {
+      nodes: flat,
+      position: iterationPosition?.position,
+      total: iterationPosition?.total
+    }) !== false
+  );
+}
+function collectRawCandidates(node, flat, declaringRole, out = []) {
+  const axis = node.presentationOf?.axis;
+  if (axis && axis.length > 0) {
+    const groups = resolveAnchoredContentPerAnchor(node, flat);
+    const iterationPosition = (iteration) => groups.length > 1 ? { position: iteration + 1, total: groups.length } : void 0;
+    groups.forEach((content, iteration) => {
+      if (!guardAllows(node, flat, iterationPosition(iteration))) {
+        return;
+      }
+      out.push({ node, declaringRole, content, iteration, iterationCount: groups.length });
+    });
+    return out;
+  }
+  if (!guardAllows(node, flat, void 0)) {
+    return out;
+  }
+  const nextRole = roleOf(node);
+  for (const child262 of node.children ?? []) {
+    collectRawCandidates(child262, flat, nextRole, out);
+  }
+  return out;
+}
 function collectChooseAwareSlots(node, flat, box, index, declaringRole) {
   const candidates = collectRawCandidates(node, flat, declaringRole);
   return resolveGroupedSlots(candidates, box, index);
@@ -36042,7 +36547,7 @@ var init_smartart_layout_interpreter_composite_choose = __esm({
   "src/core/utils/smartart-layout-interpreter-composite-choose.ts"() {
     init_smartart_constraint_solver();
     init_smartart_layout_interpreter_composite_anchor();
-    init_smartart_layout_interpreter_composite_slots();
+    init_smartart_layout_interpreter_composite_group_slots();
     init_smartart_layout_interpreter_render();
     init_smartart_layout_interpreter_when();
   }
@@ -36280,165 +36785,6 @@ var init_smartart_layout_interpreter_composite = __esm({
     init_smartart_node_tree_axis();
   }
 });
-function resolveHubToNodeRatio(ringItem, arrangerConstraints) {
-  if (!ringItem?.name) {
-    return void 0;
-  }
-  const match = (arrangerConstraints ?? []).find(
-    (c) => c.type === "w" && c.forName === ringItem.name && c.referenceType === "w" && (c.factor === void 0 || typeof c.factor === "number" && c.factor > 0) && typeof c.referenceForName === "string"
-  );
-  if (!match) {
-    return void 0;
-  }
-  return { hubName: match.referenceForName, factor: match.factor ?? 1 };
-}
-function resolveHubGapRatio(itemName, hubRatio, arrangerConstraints) {
-  if (!hubRatio) {
-    return void 0;
-  }
-  const sp = (arrangerConstraints ?? []).find(
-    (c) => c.type === "sp" && typeof c.factor === "number" && typeof c.referenceForName === "string"
-  );
-  if (!sp || typeof sp.factor !== "number") {
-    return void 0;
-  }
-  if (sp.referenceForName === itemName) {
-    return sp.factor;
-  }
-  if (sp.referenceForName === hubRatio.hubName) {
-    return sp.factor / hubRatio.factor;
-  }
-  return void 0;
-}
-var init_smartart_layout_interpreter_cycle_hub_ratio = __esm({
-  "src/core/utils/smartart-layout-interpreter-cycle-hub-ratio.ts"() {
-  }
-});
-function deriveCompositeSquareChildAspect(item) {
-  if (!item || item.algorithm?.type !== "composite") {
-    return void 0;
-  }
-  const constraints = item.allConstraints ?? item.constraints ?? [];
-  for (const width of constraints) {
-    if (width.type !== "w" || width.for !== "ch" || !width.forName || width.referenceForName !== void 0 || typeof width.factor !== "number" || width.factor <= 0) {
-      continue;
-    }
-    const childName = width.forName;
-    const isSelfSquare = constraints.some(
-      (c) => c.type === "h" && c.for === "ch" && c.forName === childName && c.referenceType === "w" && c.referenceFor === "ch" && c.referenceForName === childName
-    );
-    if (isSelfSquare) {
-      return width.factor;
-    }
-  }
-  return void 0;
-}
-function resolveGraphAspectRatio(item, index) {
-  if (!item) {
-    return void 0;
-  }
-  const role = roleOf(item);
-  const resolvedH = resolveConstraint(index, role, "h");
-  const resolvedW = resolveConstraint(index, role, "w");
-  if (resolvedH === void 0 || resolvedW === void 0 || resolvedW <= 0) {
-    return void 0;
-  }
-  return resolvedH / resolvedW;
-}
-var init_smartart_layout_interpreter_cycle_item_aspect = __esm({
-  "src/core/utils/smartart-layout-interpreter-cycle-item-aspect.ts"() {
-    init_smartart_constraint_solver();
-  }
-});
-function absoluteConstraintPoints(constraint) {
-  if (constraint === void 0 || constraint.factor !== void 0 || constraint.referenceType !== void 0 || typeof constraint.value !== "number" || !Number.isFinite(constraint.value) || constraint.value < 1) {
-    return void 0;
-  }
-  return constraint.value;
-}
-function resolveCycleConstraintNode(arrangerNode) {
-  if (arrangerNode.name === "cycle") {
-    return arrangerNode;
-  }
-  for (const child262 of arrangerNode.children ?? []) {
-    if (child262.name === "cycle") {
-      return child262;
-    }
-  }
-  return arrangerNode;
-}
-function resolveRingItemNode(constraintNode, arrangerConstraints) {
-  const sibSpName = (arrangerConstraints ?? []).find(
-    (c) => c.type === "sibSp" && typeof c.referenceForName === "string"
-  )?.referenceForName;
-  const named = sibSpName ? (constraintNode.children ?? []).find((child262) => child262.name === sibSpName) : void 0;
-  if (named?.forEachOrigin) {
-    return named;
-  }
-  const repeating = (constraintNode.children ?? []).find((child262) => child262.forEachOrigin);
-  return repeating ?? named ?? itemNode(constraintNode);
-}
-function resolveCycleRingParams(arrangerNode, index) {
-  const constraintNode = resolveCycleConstraintNode(arrangerNode);
-  const arrangerConstraints = constraintNode.allConstraints ?? constraintNode.constraints;
-  const item = resolveRingItemNode(constraintNode, arrangerConstraints);
-  const itemConstraints = item?.allConstraints ?? item?.constraints;
-  const literalHeightOverWidth = ratioConstraint(
-    itemConstraints ?? [],
-    ["h"],
-    Number.NaN,
-    item?.rules
-  );
-  const heightOverWidth = !Number.isNaN(literalHeightOverWidth) ? literalHeightOverWidth : resolveGraphAspectRatio(item, index) ?? resolveRatioConstraint(
-    itemConstraints,
-    index,
-    roleOf(item),
-    ["h"],
-    deriveCompositeSquareChildAspect(item) ?? 1,
-    item?.rules
-  );
-  const hubRatio = resolveHubToNodeRatio(item, arrangerConstraints);
-  const hubGapRatio = resolveHubGapRatio(item?.name, hubRatio, arrangerConstraints);
-  const absolutePoints = absoluteConstraintPoints(findConstraint(arrangerConstraints, "sibSp"));
-  if (absolutePoints !== void 0) {
-    return {
-      minGapRatio: DEFAULT_MIN_GAP_RATIO,
-      heightOverWidth,
-      absoluteGapPx: absolutePoints * POINTS_TO_PIXELS3,
-      hubRatio,
-      hubGapRatio
-    };
-  }
-  const minGapRatio = resolveRatioConstraint(
-    arrangerConstraints,
-    index,
-    roleOf(constraintNode),
-    ["sibSp"],
-    DEFAULT_MIN_GAP_RATIO,
-    constraintNode.rules
-  );
-  return {
-    minGapRatio: Math.max(DEFAULT_MIN_GAP_RATIO, minGapRatio),
-    heightOverWidth,
-    hubRatio,
-    hubGapRatio
-  };
-}
-var POINTS_TO_PIXELS3;
-var DEFAULT_MIN_GAP_RATIO;
-var init_smartart_layout_interpreter_cycle_constraints = __esm({
-  "src/core/utils/smartart-layout-interpreter-cycle-constraints.ts"() {
-    init_smartart_constraint_ratio_fallback();
-    init_smartart_constraint_solver();
-    init_smartart_layout_interpreter_constraints();
-    init_smartart_layout_interpreter_cycle_hub_ratio();
-    init_smartart_layout_interpreter_cycle_item_aspect();
-    init_smartart_layout_interpreter_model();
-    init_smartart_layout_interpreter_cycle_hub_ratio();
-    POINTS_TO_PIXELS3 = 96 / 72;
-    DEFAULT_MIN_GAP_RATIO = 0.5;
-  }
-});
 function degenerateRingLayout(n, heightOverWidth, box) {
   const boxCentre = { x: box.width / 2, y: box.height / 2 };
   if (n <= 0) {
@@ -36493,22 +36839,18 @@ function ringLayoutForGapFactor(n, stAngDeg, spanDeg, gapFactor, heightOverWidth
   const maxX = Math.max(...xs) + halfW;
   const minY = Math.min(...ys) - halfH;
   const maxY = Math.max(...ys) + halfH;
-  const spreadX = Math.max(...xs) - Math.min(...xs);
-  const spreadY = Math.max(...ys) - Math.min(...ys);
   const naturalBoundW = Math.max(1e-6, maxX - minX);
   const naturalBoundH = Math.max(1e-6, maxY - minY);
-  let scaleX = box.width / naturalBoundW;
-  let scaleY = box.height / naturalBoundH;
-  if (spreadX < 1e-6 && spreadY >= 1e-6) {
-    scaleX = scaleY;
-  } else if (spreadY < 1e-6 && spreadX >= 1e-6) {
-    scaleY = scaleX;
-  }
+  const scale2 = Math.min(box.width / naturalBoundW, box.height / naturalBoundH);
+  const scaleX = scale2;
+  const scaleY = scale2;
+  const offsetX = (box.width - naturalBoundW * scale2) / 2;
+  const offsetY = (box.height - naturalBoundH * scale2) / 2;
   const centers = natural.map((p) => ({
-    x: (p.x - minX) * scaleX,
-    y: (p.y - minY) * scaleY
+    x: (p.x - minX) * scaleX + offsetX,
+    y: (p.y - minY) * scaleY + offsetY
   }));
-  const hubCenter = { x: (0 - minX) * scaleX, y: (0 - minY) * scaleY };
+  const hubCenter = { x: (0 - minX) * scaleX + offsetX, y: (0 - minY) * scaleY + offsetY };
   const naturalHubRadius = Math.max(0, r0 - Math.max(halfW, halfH));
   return {
     centers,
@@ -36519,12 +36861,14 @@ function ringLayoutForGapFactor(n, stAngDeg, spanDeg, gapFactor, heightOverWidth
     hubHalfHeight: naturalHubRadius * scaleY
   };
 }
-function computeCycleRingLayout(n, stAngDeg, spanDeg, minGapRatio, heightOverWidth, box, absoluteGapPx, hubGeometry) {
+function computeCycleRingLayout(n, stAngDeg, spanDeg, minGapRatio, heightOverWidth, box, absoluteGapPx, hubGeometry, absoluteHubGapPx) {
   const degenerate = degenerateRingLayout(n, heightOverWidth, box);
   if (degenerate) {
     return degenerate;
   }
-  if (absoluteGapPx === void 0 || absoluteGapPx <= 0) {
+  const needsGapIteration = absoluteGapPx !== void 0 && absoluteGapPx > 0;
+  const needsHubGapIteration = absoluteHubGapPx !== void 0 && absoluteHubGapPx > 0 && hubGeometry !== void 0;
+  if (!needsGapIteration && !needsHubGapIteration) {
     return ringLayoutForGapFactor(
       n,
       stAngDeg,
@@ -36536,6 +36880,7 @@ function computeCycleRingLayout(n, stAngDeg, spanDeg, minGapRatio, heightOverWid
     );
   }
   let gapFactor = minGapRatio;
+  let hub = hubGeometry;
   for (let iteration = 0; iteration < 20; iteration += 1) {
     const candidate = ringLayoutForGapFactor(
       n,
@@ -36544,16 +36889,21 @@ function computeCycleRingLayout(n, stAngDeg, spanDeg, minGapRatio, heightOverWid
       gapFactor,
       heightOverWidth,
       box,
-      hubGeometry
+      hub
     );
-    const nextGapFactor = candidate.nodeWidth > 1e-6 ? absoluteGapPx / candidate.nodeWidth : gapFactor;
-    if (Math.abs(nextGapFactor - gapFactor) < 1e-9) {
-      gapFactor = nextGapFactor;
+    const nextGapFactor = needsGapIteration && candidate.nodeWidth > 1e-6 ? absoluteGapPx / candidate.nodeWidth : gapFactor;
+    const nextHubGapRatio = needsHubGapIteration && candidate.nodeWidth > 1e-6 ? absoluteHubGapPx / candidate.nodeWidth : hub?.gapRatio;
+    const gapConverged = Math.abs(nextGapFactor - gapFactor) < 1e-9;
+    const hubGapConverged = !needsHubGapIteration || Math.abs((nextHubGapRatio ?? 0) - (hub?.gapRatio ?? 0)) < 1e-9;
+    gapFactor = nextGapFactor;
+    if (needsHubGapIteration && hub) {
+      hub = { ...hub, gapRatio: nextHubGapRatio ?? hub.gapRatio };
+    }
+    if (gapConverged && hubGapConverged) {
       break;
     }
-    gapFactor = nextGapFactor;
   }
-  return ringLayoutForGapFactor(n, stAngDeg, spanDeg, gapFactor, heightOverWidth, box, hubGeometry);
+  return ringLayoutForGapFactor(n, stAngDeg, spanDeg, gapFactor, heightOverWidth, box, hub);
 }
 var DEG_TO_RAD;
 var init_smartart_layout_interpreter_cycle_ring = __esm({
@@ -36564,14 +36914,14 @@ var init_smartart_layout_interpreter_cycle_ring = __esm({
 function arrangeCycle(plan, nodes, box, palette, style, elementId, index = EMPTY_CONSTRAINT_INDEX, hubAlreadyStripped = false) {
   const { width: w, height: h2 } = box;
   const ctx = styleContext(style);
-  const { minGapRatio, heightOverWidth, absoluteGapPx, hubRatio, hubGapRatio } = resolveCycleRingParams(plan.node, index);
+  const { minGapRatio, heightOverWidth, absoluteGapPx, hubRatio, hubGapRatio, absoluteHubGapPx } = resolveCycleRingParams(plan.node, index);
   const hasHub = !hubAlreadyStripped && !hubRatio && algorithmParam(plan.node, "ctrShpMap") === "fNode" && nodes.length > 0;
   const hubNode = hasHub ? nodes[0] : void 0;
   const ringNodes = hasHub ? nodes.slice(1) : nodes;
   const n = ringNodes.length;
   const startDeg = numericParam(plan.node, "stAng", 0);
   const spanDeg = numericParam(plan.node, "spanAng", 360);
-  const hubGeometry = hubRatio && hubGapRatio !== void 0 ? { factor: hubRatio.factor, gapRatio: hubGapRatio } : void 0;
+  const hubGeometry = hubRatio && (hubGapRatio !== void 0 || absoluteHubGapPx !== void 0) ? { factor: hubRatio.factor, gapRatio: hubGapRatio ?? 0 } : void 0;
   const ring = computeCycleRingLayout(
     n,
     startDeg,
@@ -36580,7 +36930,8 @@ function arrangeCycle(plan, nodes, box, palette, style, elementId, index = EMPTY
     heightOverWidth,
     box,
     absoluteGapPx,
-    hubGeometry
+    hubGeometry,
+    absoluteHubGapPx
   );
   const full = Math.abs(spanDeg) >= 360;
   const connectorCount = n > 0 ? full ? n : Math.max(0, n - 1) : 0;
@@ -37094,6 +37445,58 @@ var init_smartart_hierarchy_hanging = __esm({
     init_smartart_hierarchy_shared();
   }
 });
+function findCompositeDescendant(node) {
+  if (!node) {
+    return void 0;
+  }
+  if (node.algorithm?.type === "composite") {
+    return node;
+  }
+  for (const child262 of node.children ?? []) {
+    const found = findCompositeDescendant(child262);
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+function findTextBearingChild(compositeNode) {
+  return (compositeNode.children ?? []).find(
+    (child262) => (child262.presentationOf?.axis ?? []).includes("self")
+  );
+}
+function resolveCompositeChildGeometry(algorithmNode) {
+  const compositeNode = findCompositeDescendant(algorithmNode);
+  if (!compositeNode) {
+    return void 0;
+  }
+  const child262 = findTextBearingChild(compositeNode);
+  if (!child262?.name) {
+    return void 0;
+  }
+  const constraints = compositeNode.allConstraints ?? compositeNode.constraints ?? [];
+  const widthConstr = constraints.find(
+    (c) => c.type === "w" && c.for === "ch" && c.forName === child262.name && c.referenceType === "w" && c.referenceForName === void 0 && typeof c.factor === "number"
+  );
+  const heightConstr = constraints.find(
+    (c) => c.type === "h" && c.for === "ch" && c.forName === child262.name && c.referenceType === "w" && c.referenceFor === "ch" && c.referenceForName === child262.name && typeof c.factor === "number"
+  );
+  const leftConstr = constraints.find(
+    (c) => c.type === "l" && c.for === "ch" && c.forName === child262.name && c.referenceType === "w" && c.referenceForName === void 0 && typeof c.factor === "number"
+  );
+  if (!widthConstr || !heightConstr || widthConstr.factor === void 0 || widthConstr.factor <= 0) {
+    return void 0;
+  }
+  return {
+    aspectRatio: heightConstr.factor,
+    widthFactor: widthConstr.factor,
+    offsetXRatio: leftConstr?.factor ?? 0
+  };
+}
+var init_smartart_hierarchy_composite_child = __esm({
+  "src/core/utils/smartart-hierarchy-composite-child.ts"() {
+  }
+});
 function transposeNode(node) {
   switch (node.kind) {
     case "rect":
@@ -37158,7 +37561,8 @@ function fitItemBox(box, columns, levels, sibSpRatio, aspectRatio, generationGap
   const heightFit = usableH / (generations + maxHangDepth + Math.max(0, generations - 1) * generationGapRatio + maxHangDepth * HANG_HEIGHT_RATIO);
   const naturalHeight = widthFit * aspectRatio;
   const boxH = clampToNaturalAspect ? Math.min(naturalHeight, heightFit) : heightFit;
-  return { boxW: Math.max(1, widthFit), boxH: Math.max(1, boxH) };
+  const boxW = clampToNaturalAspect ? boxH / aspectRatio : widthFit;
+  return { boxW: Math.max(1, boxW), boxH: Math.max(1, boxH) };
 }
 var init_smartart_hierarchy_fit_item_box = __esm({
   "src/core/utils/smartart-hierarchy-fit-item-box.ts"() {
@@ -37182,7 +37586,7 @@ function resolveAspectRatio(constraints) {
   }
   return DEFAULT_ASPECT_RATIO;
 }
-function resolveGenerationGapRatio(constraints, stackingAxis, aspectRatio) {
+function resolveGenerationGapRatio(constraints, stackingAxis, aspectRatio, compositeChild, compositeAspect) {
   const onStackingAxis = findByReference(constraints, "sp", stackingAxis);
   if (onStackingAxis !== void 0) {
     return onStackingAxis;
@@ -37217,10 +37621,15 @@ function resolveHierarchyOrientation(algorithmNode, index, mode = "std") {
       // See `OUTER_MARGIN_X_RATIO`'s doc comment: a transposed hierarchy
       // needs no outer margin at all on either axis, COM-verified.
       marginXRatio: 0,
-      marginYRatio: 0
+      marginYRatio: 0,
+      // A transposed hierarchy declares no `composite` wrapper (see
+      // `smartart-hierarchy-composite-child.ts`'s own module doc comment) -
+      // nothing to correct or offset from.
+      cardOffsetXRatio: 0
     };
   }
-  const aspectRatio = resolveAspectRatio(constraints);
+  const compositeChild = resolveCompositeChildGeometry(algorithmNode);
+  const aspectRatio = compositeChild?.aspectRatio ?? resolveAspectRatio(constraints);
   const tailedMargin = mode === "tailed";
   return {
     transposed: false,
@@ -37228,7 +37637,9 @@ function resolveHierarchyOrientation(algorithmNode, index, mode = "std") {
     aspectRatio,
     generationGapRatio: resolveGenerationGapRatio(constraints, "h", aspectRatio),
     marginXRatio: tailedMargin ? 0 : OUTER_MARGIN_X_RATIO,
-    marginYRatio: tailedMargin ? 0 : OUTER_MARGIN_Y_RATIO
+    marginYRatio: tailedMargin ? 0 : OUTER_MARGIN_Y_RATIO,
+    compositeWidthFactor: compositeChild?.widthFactor,
+    cardOffsetXRatio: compositeChild?.offsetXRatio ?? 0
   };
 }
 var DEFAULT_ASPECT_RATIO;
@@ -37240,6 +37651,7 @@ var init_smartart_hierarchy_orientation = __esm({
   "src/core/utils/smartart-hierarchy-orientation.ts"() {
     init_smartart_constraint_ratio_fallback();
     init_smartart_constraint_solver();
+    init_smartart_hierarchy_composite_child();
     init_smartart_hierarchy_transpose();
     init_smartart_hierarchy_fit_item_box();
     init_smartart_hierarchy_child_order();
@@ -37258,6 +37670,21 @@ function computeAxisPitch(dimension, margin, itemSize, count) {
   const maxShift = dimension - n * itemSize - gap * (n - 0.5);
   return { pitch, shift: Math.min(rawShift, maxShift) };
 }
+function centeredAxisPitch(dimension, itemSize, gapRatio, count) {
+  const n = Math.max(1, count);
+  const gap = n > 1 ? itemSize * Math.max(0, gapRatio) : 0;
+  const pitch = itemSize + gap;
+  const span = n * itemSize + Math.max(0, n - 1) * gap;
+  const shift = (dimension - span) / 2;
+  return { pitch, shift };
+}
+function compositeFanPitch(dimension, boxW, compositeWidthFactor, cardOffsetXRatio, sibSpRatio, count) {
+  const compositeW = compositeWidthFactor ? boxW / compositeWidthFactor : boxW;
+  const cardOffsetX = cardOffsetXRatio * compositeW;
+  const centred = centeredAxisPitch(dimension, compositeW, sibSpRatio, count);
+  const correction = cardOffsetX + boxW / 2 - centred.pitch / 2;
+  return { pitch: centred.pitch, shift: centred.shift + correction };
+}
 function translateNode(node, dx, dy) {
   switch (node.kind) {
     case "rect":
@@ -37309,11 +37736,9 @@ function translateResult(result, dx, dy) {
   return { ...result, nodes, connectors };
 }
 var GENERATION_MARGIN_RATIO;
-var FAN_MARGIN_RATIO;
 var init_smartart_hierarchy_pitch = __esm({
   "src/core/utils/smartart-hierarchy-pitch.ts"() {
     GENERATION_MARGIN_RATIO = 0.1675;
-    FAN_MARGIN_RATIO = 0.1115;
   }
 });
 function planFan(childCount, perRow, siblingCxs) {
@@ -37672,11 +38097,17 @@ function arrangeHierarchy(nodes, box, palette, style, elementId, presLayoutVars,
     mode !== "tailed"
   );
   const tailedPitch = mode === "tailed";
-  const fanMargin = orientation.transposed || tailedPitch ? 0 : boxW * FAN_MARGIN_RATIO;
   const generationMargin = orientation.transposed || tailedPitch ? 0 : boxH * GENERATION_MARGIN_RATIO;
   const fanWidth = tailedPitch ? effectiveBox.width - hangShape.maxHangDepth * HIER_TAIL_OFFSET_RATIO * boxW : effectiveBox.width;
   const fanHeight = tailedPitch ? effectiveBox.height - hangShape.maxHangDepth * (1 + HANG_HEIGHT_RATIO) * boxH : effectiveBox.height;
-  const xPitch = computeAxisPitch(fanWidth, fanMargin, boxW, totalLeaves);
+  const xPitch = compositeFanPitch(
+    fanWidth,
+    boxW,
+    orientation.compositeWidthFactor,
+    orientation.cardOffsetXRatio,
+    orientation.sibSpRatio,
+    totalLeaves
+  );
   const yPitch = computeAxisPitch(fanHeight, generationMargin, boxH, depth);
   const cellW = xPitch.pitch;
   const cellH = yPitch.pitch;
@@ -38056,15 +38487,24 @@ function stackRoleContent(content, arrangerRole, original, index) {
   if (original.kind === "rect") {
     return stackAsRect(content, arrangerRole, original, boundingBoxOf(original), index);
   }
-  if (original.kind !== "polygon" && (everyRoleIsRect || hasMixedExplicitKinds)) {
+  if (everyRoleIsRect) {
     return stackAsRect(content, arrangerRole, original, boundingBoxOf(original), index);
   }
-  if (original.kind !== "polygon") {
-    return void 0;
+  if (original.kind === "polygon") {
+    return splitAsUnchangedCopy(content, original);
+  }
+  if (original.kind === "circle") {
+    return hasMixedExplicitKinds ? splitAsUnchangedCopy(content, original) : void 0;
+  }
+  if (hasMixedExplicitKinds) {
+    return stackAsRect(content, arrangerRole, original, boundingBoxOf(original), index);
   }
+  return void 0;
+}
+function splitAsUnchangedCopy(content, original) {
   return content.map((entry2, i2) => {
     const fields = splitEntryFields(entry2, `${original.key}-role${i2}`, original);
-    const isSelfRole = entry2.role.presentationOf?.axis?.includes("self") ?? false;
+    const isSelfRole = original.kind === "polygon" && (entry2.role.presentationOf?.axis?.includes("self") ?? false);
     const presetOverride = isSelfRole ? original.presetOverride : fields.presetOverride;
     return { ...original, ...fields, presetOverride };
   });
@@ -38496,7 +38936,7 @@ function runArrangement(input) {
     );
   }
   const roots = topLevelSmartArtNodes(nodes);
-  const childrenOf = smartArtChildrenOf(nodes);
+  const childrenOf = smartArtChildrenOf(nodes, input.connections);
   const preArranged = plan.kind === "composite" ? roots.length > 0 ? roots : flat : selectArrangedNodes(plan.node, flat, roots);
   const hub = detectHubExpansion(plan.node, preArranged, childrenOf);
   const arranged = hub ? applyChildOrder(hub.satellites, buildChildOrder(input.connections)) : preArranged;
@@ -38544,8 +38984,13 @@ function runArrangement(input) {
     hasAccentSomewhere,
     constraintIndex
   ) : withItemRoles;
+  const withCycleRingContent = plan.kind === "cycle" ? repositionCycleRingContent(
+    withPyramidBands,
+    resolveCycleRingParams(plan.node, constraintIndex).contentLayout,
+    flat
+  ) : withPyramidBands;
   if (!hub) {
-    return withPyramidBands;
+    return withCycleRingContent;
   }
   const hubNode = buildHubRenderedNode(
     plan.node,
@@ -38557,7 +39002,7 @@ function runArrangement(input) {
     hub.satellites.length,
     constraintIndex
   );
-  return { ...withPyramidBands, nodes: [hubNode, ...withPyramidBands.nodes] };
+  return { ...withCycleRingContent, nodes: [hubNode, ...withCycleRingContent.nodes] };
 }
 function interpretSmartArtLayout(input) {
   const result = runArrangement(input);
@@ -38574,6 +39019,8 @@ var init_smartart_layout_interpreter = __esm({
     init_smartart_hierarchy_child_order();
     init_smartart_layout_interpreter_connector_order();
     init_smartart_layout_interpreter_custom();
+    init_smartart_layout_interpreter_cycle_constraints();
+    init_smartart_layout_interpreter_cycle_ring_item();
     init_smartart_layout_interpreter_dispatch();
     init_smartart_layout_interpreter_flow();
     init_smartart_layout_interpreter_hierarchy();
@@ -38926,7 +39373,8 @@ function computeSmartArtElementsWithoutCache(smartArtData, containerBounds, them
         interpreted,
         nodes,
         containerBounds,
-        smartArtData.presLayoutVars?.bulletEnabled
+        smartArtData.presLayoutVars?.bulletEnabled,
+        smartArtData.connections
       );
     }
   }
@@ -50124,13 +50572,14 @@ function nestedLayoutNodes(node, localName28) {
       } else if (name === "if") {
         for (const ifNode of Array.isArray(entry2) ? entry2 : [entry2]) {
           if (ifNode && typeof ifNode === "object") {
-            visit(ifNode, origin, parseWhen(ifNode));
+            const when = parseWhen(ifNode);
+            visit(ifNode, origin, when ? [...guard, when] : guard);
           }
         }
       } else if (name === "else") {
         for (const elseNode of Array.isArray(entry2) ? entry2 : [entry2]) {
           if (elseNode && typeof elseNode === "object") {
-            visit(elseNode, origin, void 0);
+            visit(elseNode, origin, guard);
           }
         }
       } else {
@@ -50140,7 +50589,7 @@ function nestedLayoutNodes(node, localName28) {
   };
   for (const [key2, value] of Object.entries(node)) {
     if (!key2.startsWith("@_") && localName28(key2) !== "extLst") {
-      visit({ [key2]: value }, void 0, void 0);
+      visit({ [key2]: value }, void 0, []);
     }
   }
   return found;
@@ -50311,7 +50760,7 @@ function parseNode(node, localName28) {
   const nested = nestedLayoutNodes(node, localName28).map((entry2) => ({
     ...parseNode(entry2.xml, localName28),
     forEachOrigin: entry2.origin,
-    chooseGuard: entry2.guard
+    chooseGuard: entry2.guard.length > 0 ? entry2.guard : void 0
   }));
   const childOrder3 = optionalString4(node["@_chOrder"]);
   const presOf = choosePresentationOf(node, localName28);