pptx-react-viewer 3.12.0 → 3.13.0

package/dist/{chunk-3WK4AE52.js → chunk-TWUAZRCG.js}

@@ -5503,8 +5503,8 @@ function read255Short(s) {
   }
   return value * sign;
 }
-function unpackCVT(table, sIn) {
-  sIn.seekAbsolute(table.offset);
+function unpackCVT(table2, sIn) {
+  sIn.seekAbsolute(table2.offset);
   const numEntries = sIn.readU16();
   const out = new Stream(null, 0);
   out.reserve(numEntries * 2);
@@ -5524,8 +5524,8 @@ function unpackCVT(table, sIn) {
     lastValue = toInt16(lastValue + val2);
     out.writeS16(lastValue);
   }
-  table.buf = out.toUint8Array();
-  table.bufSize = table.buf.length;
+  table2.buf = out.toUint8Array();
+  table2.bufSize = table2.buf.length;
 }
 function decodePushInstructions(sIn, sOut, pushCount) {
   if (pushCount === 0) {
@@ -5863,13 +5863,13 @@ function populateGlyfAndLoca(glyf, loca, headData, maxpData, streams) {
   loca.buf = locaStream.toUint8Array();
   loca.bufSize = loca.buf.length;
 }
-function parseHead(table) {
-  const s = new Stream(table.buf, table.bufSize);
+function parseHead(table2) {
+  const s = new Stream(table2.buf, table2.bufSize);
   s.seekAbsolute(50);
   return { indexToLocFormat: s.readS16() };
 }
-function parseMaxp(table) {
-  const s = new Stream(table.buf, table.bufSize);
+function parseMaxp(table2) {
+  const s = new Stream(table2.buf, table2.bufSize);
   const version = s.readU32();
   const numGlyphs = s.readU16();
   let maxPoints = 0;
@@ -5923,7 +5923,7 @@ function parseCTF(streams, options) {
     s0.seekRelative(4);
     const offset = s0.readU32();
     const size = s0.readU32();
-    const table = {
+    const table2 = {
       tag,
       offset,
       bufSize: size,
@@ -5931,7 +5931,7 @@ function parseCTF(streams, options) {
       checksum: 0
     };
     const idx = tables.length;
-    tables.push(table);
+    tables.push(table2);
     if (tag === "glyf") {
       glyfIdx = idx;
     } else if (tag === "loca") {
@@ -5945,31 +5945,31 @@ function parseCTF(streams, options) {
     } else ;
   }
   for (let i2 = 0; i2 < tables.length; i2++) {
-    const table = tables[i2];
-    if (table.tag === "glyf" || table.tag === "loca") {
+    const table2 = tables[i2];
+    if (table2.tag === "glyf" || table2.tag === "loca") {
       continue;
     }
-    if (table.tag === "cvt ") {
-      unpackCVT(table, s0);
+    if (table2.tag === "cvt ") {
+      unpackCVT(table2, s0);
       continue;
     }
-    s0.seekAbsolute(table.offset);
-    const buf = new Uint8Array(table.bufSize);
-    for (let b = 0; b < table.bufSize; b++) {
+    s0.seekAbsolute(table2.offset);
+    const buf = new Uint8Array(table2.bufSize);
+    for (let b = 0; b < table2.bufSize; b++) {
       buf[b] = s0.readU8();
     }
-    table.buf = buf;
-    if (table.tag === "head") {
-      if (table.bufSize < 12) {
+    table2.buf = buf;
+    if (table2.tag === "head") {
+      if (table2.bufSize < 12) {
         throw new EotError(
           "MALFORMED_HEAD_TABLE",
-          `head table too small: ${table.bufSize} bytes (need at least 12)`
+          `head table too small: ${table2.bufSize} bytes (need at least 12)`
         );
       }
-      table.buf[8] = 0;
-      table.buf[9] = 0;
-      table.buf[10] = 0;
-      table.buf[11] = 0;
+      table2.buf[8] = 0;
+      table2.buf[9] = 0;
+      table2.buf[10] = 0;
+      table2.buf[11] = 0;
     }
   }
   if (maxpIdx < 0) {
@@ -6485,21 +6485,21 @@ function writeOffsetTable(ctr, out) {
   out.writeU16(rangeShift);
 }
 function writeTableDirectory(ctr, out) {
-  for (const table of ctr.tables) {
-    out.writeU8(table.tag.charCodeAt(0));
-    out.writeU8(table.tag.charCodeAt(1));
-    out.writeU8(table.tag.charCodeAt(2));
-    out.writeU8(table.tag.charCodeAt(3));
-    out.writeU32(table.checksum);
-    out.writeU32(table.offset);
-    out.writeU32(table.bufSize);
-  }
-}
-function writeTableCheckingSum(table, out) {
-  table.offset = out.pos;
+  for (const table2 of ctr.tables) {
+    out.writeU8(table2.tag.charCodeAt(0));
+    out.writeU8(table2.tag.charCodeAt(1));
+    out.writeU8(table2.tag.charCodeAt(2));
+    out.writeU8(table2.tag.charCodeAt(3));
+    out.writeU32(table2.checksum);
+    out.writeU32(table2.offset);
+    out.writeU32(table2.bufSize);
+  }
+}
+function writeTableCheckingSum(table2, out) {
+  table2.offset = out.pos;
   let checksum = 0;
-  const data = table.buf;
-  const len = table.bufSize;
+  const data = table2.buf;
+  const len = table2.bufSize;
   const fullWords = Math.floor(len / 4);
   const remainder = len % 4;
   for (let i2 = 0; i2 < fullWords; i2++) {
@@ -6517,7 +6517,7 @@ function writeTableCheckingSum(table, out) {
     checksum = checksum + word >>> 0;
     out.writeU32(word);
   }
-  table.checksum = checksum;
+  table2.checksum = checksum;
 }
 function getTableDirectorySize(ctr) {
   return 16 * ctr.tables.length;
@@ -6526,8 +6526,8 @@ function getRequiredSize(ctr) {
   const offsetTableSize = 12;
   const dirSize = getTableDirectorySize(ctr);
   let tableDataSize = 0;
-  for (const table of ctr.tables) {
-    tableDataSize += Math.ceil(table.bufSize / 4) * 4;
+  for (const table2 of ctr.tables) {
+    tableDataSize += Math.ceil(table2.bufSize / 4) * 4;
   }
   return offsetTableSize + dirSize + tableDataSize;
 }
@@ -6539,14 +6539,14 @@ function dumpContainer(ctr) {
   const dirSize = getTableDirectorySize(ctr);
   out.pos += dirSize;
   let totalChecksum = 0;
-  for (const table of ctr.tables) {
-    writeTableCheckingSum(table, out);
-    totalChecksum = totalChecksum + table.checksum >>> 0;
+  for (const table2 of ctr.tables) {
+    writeTableCheckingSum(table2, out);
+    totalChecksum = totalChecksum + table2.checksum >>> 0;
   }
   let headTable;
-  for (const table of ctr.tables) {
-    if (table.tag === "head") {
-      headTable = table;
+  for (const table2 of ctr.tables) {
+    if (table2.tag === "head") {
+      headTable = table2;
       break;
     }
   }
@@ -16546,8 +16546,8 @@ function gd14(name, formula) {
   const parts = formula.trim().split(/\s+/);
   return { name, formula, args: parts.slice(1) };
 }
-function parseGdTable(table) {
-  return table.trim().split(/[\n;]/).filter((entry2) => entry2.length > 0).map((entry2) => {
+function parseGdTable(table2) {
+  return table2.trim().split(/[\n;]/).filter((entry2) => entry2.length > 0).map((entry2) => {
     const sep = entry2.indexOf("|");
     return gd14(entry2.slice(0, sep), entry2.slice(sep + 1));
   });
@@ -28579,21 +28579,21 @@ function parseBteTable(tableStream, at) {
   }
   return { fcs, pns };
 }
-function buildBteTableBytes(table) {
-  const n = table.pns.length;
+function buildBteTableBytes(table2) {
+  const n = table2.pns.length;
   const bytes = new Uint8Array((n + 1) * 4 + n * 4);
   const view = new DataView(bytes.buffer);
   for (let i2 = 0; i2 <= n; i2++) {
-    view.setInt32(i2 * 4, table.fcs[i2], true);
+    view.setInt32(i2 * 4, table2.fcs[i2], true);
   }
   for (let i2 = 0; i2 < n; i2++) {
-    view.setUint32((n + 1) * 4 + i2 * 4, table.pns[i2], true);
+    view.setUint32((n + 1) * 4 + i2 * 4, table2.pns[i2], true);
   }
   return bytes;
 }
-function findBteRangeIndex(table, fc) {
-  for (let i2 = 0; i2 < table.pns.length; i2++) {
-    if (fc >= table.fcs[i2] && fc < table.fcs[i2 + 1]) {
+function findBteRangeIndex(table2, fc) {
+  for (let i2 = 0; i2 < table2.pns.length; i2++) {
+    if (fc >= table2.fcs[i2] && fc < table2.fcs[i2 + 1]) {
       return i2;
     }
   }
@@ -29264,15 +29264,15 @@ var PNG_SIGNATURE;
 var init_png_encoder = __esm({
   "src/core/utils/png-encoder.ts"() {
     CRC_TABLE = (() => {
-      const table = new Uint32Array(256);
+      const table2 = new Uint32Array(256);
       for (let n = 0; n < 256; n++) {
         let c = n;
         for (let k = 0; k < 8; k++) {
           c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
         }
-        table[n] = c >>> 0;
+        table2[n] = c >>> 0;
       }
-      return table;
+      return table2;
     })();
     PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
   }
@@ -32943,6 +32943,63 @@ var init_smartart_layout_interpreter_axis_count = __esm({
     init_smartart_layout_interpreter_axis_hop();
   }
 });
+function depthFromAnchor(node, anchorId, byId) {
+  let depth = 0;
+  let current = node;
+  const seen = /* @__PURE__ */ new Set();
+  while (current) {
+    if (current.id === anchorId) {
+      return depth;
+    }
+    if (seen.has(current.id)) {
+      return void 0;
+    }
+    seen.add(current.id);
+    current = current.parentId ? byId.get(current.parentId) : void 0;
+    depth += 1;
+  }
+  return void 0;
+}
+function resolveAxisMaxDepth(nodes, axis, pointTypes, start, count, anchor) {
+  if (anchor.length === 0) {
+    return void 0;
+  }
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  let max = 0;
+  for (const anchorPoint of anchor) {
+    const resolved = resolveAxisNodes(nodes, axis, pointTypes, start, count, [anchorPoint]);
+    if (resolved === void 0) {
+      return void 0;
+    }
+    for (const point of resolved) {
+      const depth = depthFromAnchor(point, anchorPoint.id, byId);
+      if (depth !== void 0 && depth > max) {
+        max = depth;
+      }
+    }
+  }
+  return max;
+}
+var init_smartart_layout_interpreter_axis_depth = __esm({
+  "src/core/utils/smartart-layout-interpreter-axis-depth.ts"() {
+    init_smartart_layout_interpreter_axis_count();
+  }
+});
+function resolvePresentationOf(node, flat) {
+  const candidates = node.presentationOfCandidates;
+  if (!candidates || candidates.length === 0) {
+    return node.presentationOf;
+  }
+  const winner = candidates.find(
+    (candidate) => candidate.guard.every((guard) => evaluateWhen(guard, flat.length, { nodes: flat }) !== false)
+  );
+  return winner?.presentationOf ?? node.presentationOf;
+}
+var init_smartart_layout_interpreter_presof_choose = __esm({
+  "src/core/utils/smartart-layout-interpreter-presof-choose.ts"() {
+    init_smartart_layout_interpreter_when();
+  }
+});
 function toNumber(value) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : void 0;
@@ -33045,11 +33102,24 @@ function evaluateWhen(when, nodeCount, context) {
       return threshold === void 0 ? void 0 : compareNumeric(context.depth, when.operator, threshold);
     }
     case "maxDepth": {
-      if (context.maxDepth === void 0) {
+      const threshold = toNumber(when.value);
+      if (threshold === void 0) {
         return void 0;
       }
-      const threshold = toNumber(when.value);
-      return threshold === void 0 ? void 0 : compareNumeric(context.maxDepth, when.operator, threshold);
+      if (when.axis !== void 0 && context.anchor && context.nodes) {
+        const axisDepth = resolveAxisMaxDepth(
+          context.nodes,
+          when.axis,
+          when.pointTypes,
+          when.start,
+          when.count,
+          context.anchor
+        );
+        if (axisDepth !== void 0) {
+          return compareNumeric(axisDepth, when.operator, threshold);
+        }
+      }
+      return context.maxDepth === void 0 ? void 0 : compareNumeric(context.maxDepth, when.operator, threshold);
     }
     case "var":
       return context.presLayoutVars ? evaluateVar(when, context.presLayoutVars) : void 0;
@@ -33057,21 +33127,13 @@ function evaluateWhen(when, nodeCount, context) {
       return void 0;
   }
 }
-function resolvePresentationOf(node, flat) {
-  const candidates = node.presentationOfCandidates;
-  if (!candidates || candidates.length === 0) {
-    return node.presentationOf;
-  }
-  const winner = candidates.find(
-    (candidate) => candidate.guard.every((guard) => evaluateWhen(guard, flat.length, { nodes: flat }) !== false)
-  );
-  return winner?.presentationOf ?? node.presentationOf;
-}
 var VAR_LOOKUP;
 var VAR_DEFAULT;
 var init_smartart_layout_interpreter_when = __esm({
   "src/core/utils/smartart-layout-interpreter-when.ts"() {
     init_smartart_layout_interpreter_axis_count();
+    init_smartart_layout_interpreter_axis_depth();
+    init_smartart_layout_interpreter_presof_choose();
     VAR_LOOKUP = {
       dir: (v) => v.direction,
       hierBranch: (v) => v.hierarchyBranch,
@@ -33161,6 +33223,23 @@ function hasStructuralDescendant(node) {
     (child262) => STRUCTURAL_ALG_TYPES.has(child262.algorithm?.type ?? "") && !isContinuationForEach(child262) || hasStructuralDescendant(child262)
   );
 }
+function hasRepeatedTemplateStructuralDescendant(node) {
+  return (node.children ?? []).some((child262) => {
+    if (STRUCTURAL_ALG_TYPES.has(child262.algorithm?.type ?? "") && !isContinuationForEach(child262) && child262.forEachOrigin?.axis?.includes("ch") && child262.forEachOrigin?.pointTypes?.includes("node")) {
+      return true;
+    }
+    return hasRepeatedTemplateStructuralDescendant(child262);
+  });
+}
+function distinctMappedSlotCount(node) {
+  const names = /* @__PURE__ */ new Set();
+  for (const constraint of node.allConstraints ?? node.constraints ?? []) {
+    if (constraint.for === "ch" && constraint.forName) {
+      names.add(constraint.forName);
+    }
+  }
+  return names.size;
+}
 function mapsSlots(node) {
   const declaredByArranger = (node.allConstraints ?? node.constraints ?? []).some(
     (constraint) => constraint.for === "ch" && SLOT_CONSTRAINTS.has(constraint.type)
@@ -33195,7 +33274,14 @@ 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"]);
+    STRUCTURAL_ALG_TYPES = /* @__PURE__ */ new Set([
+      "lin",
+      "cycle",
+      "pyra",
+      "snake",
+      "hierRoot",
+      "hierChild"
+    ]);
   }
 });
 function findStructuralAlgDepth(raw, crossedNames, nodeCount, context) {
@@ -33728,8 +33814,13 @@ function discoverArrangement(definition, nodeCount, presLayoutVars, flatNodes) {
       return;
     }
     if (kind === "composite") {
-      if (!compositeSlot && !itemTemplates.has(node) && !hasStructuralDescendant(node) && mapsSlots(node)) {
+      const multiSlot = distinctMappedSlotCount(node) >= 2;
+      const repeatedTemplateDescendant = hasRepeatedTemplateStructuralDescendant(node);
+      if (!compositeSlot && !itemTemplates.has(node) && (!hasStructuralDescendant(node) || multiSlot && repeatedTemplateDescendant) && mapsSlots(node)) {
         compositeSlot = node;
+        if (multiSlot && repeatedTemplateDescendant) {
+          blockedSubtreeRoots.push(node);
+        }
       }
       return;
     }
@@ -35222,21 +35313,21 @@ var init_smartart_layout_item_font_role = __esm({
     DECORATIVE_FONT_ALGORITHM_TYPES = /* @__PURE__ */ new Set(["sp", "composite", "conn"]);
   }
 });
-function measureTextWidth(text22, fontSize, table) {
+function measureTextWidth(text22, fontSize, table2) {
   let widthPx = 0;
   for (const ch of text22) {
     const code = ch.codePointAt(0) ?? 0;
-    const unitsPerEm = table.advances[code] ?? table.averageAdvance;
+    const unitsPerEm = table2.advances[code] ?? table2.averageAdvance;
     const rawPx = unitsPerEm / 1e3 * fontSize;
     widthPx += Math.round(rawPx * ADVANCE_STEPS_PER_PX) / ADVANCE_STEPS_PER_PX;
   }
   return widthPx;
 }
-function greedyWrap(text22, maxWidth, fontSize, table) {
+function greedyWrap(text22, maxWidth, fontSize, table2) {
   if (maxWidth <= 0) {
     return { lines: Number.POSITIVE_INFINITY, widestLineWidth: 0 };
   }
-  const spaceWidth = measureTextWidth(" ", fontSize, table);
+  const spaceWidth = measureTextWidth(" ", fontSize, table2);
   let lines = 0;
   let widestLineWidth = 0;
   for (const paragraph of text22.split("\n")) {
@@ -35248,7 +35339,7 @@ function greedyWrap(text22, maxWidth, fontSize, table) {
     let lineWidth = 0;
     let paragraphLines = 1;
     for (const word of words) {
-      const wordWidth = measureTextWidth(word, fontSize, table);
+      const wordWidth = measureTextWidth(word, fontSize, table2);
       const extended = lineWidth === 0 ? wordWidth : lineWidth + spaceWidth + wordWidth;
       if (extended > maxWidth && lineWidth > 0) {
         widestLineWidth = Math.max(widestLineWidth, lineWidth);
@@ -35263,30 +35354,30 @@ function greedyWrap(text22, maxWidth, fontSize, table) {
   }
   return { lines: Math.max(1, lines), widestLineWidth };
 }
-function wrappedLineCount(text22, maxWidth, fontSize, table) {
-  return greedyWrap(text22, maxWidth, fontSize, table).lines;
+function wrappedLineCount(text22, maxWidth, fontSize, table2) {
+  return greedyWrap(text22, maxWidth, fontSize, table2).lines;
 }
-function wrappedWidestLineWidth(text22, maxWidth, fontSize, table) {
-  return greedyWrap(text22, maxWidth, fontSize, table).widestLineWidth;
+function wrappedWidestLineWidth(text22, maxWidth, fontSize, table2) {
+  return greedyWrap(text22, maxWidth, fontSize, table2).widestLineWidth;
 }
-function fitsAt(text22, maxWidth, maxHeight, size, table, lineSpacingFactor) {
-  return wrappedLineCount(text22, maxWidth, size, table) * size * table.lineHeightRatio * lineSpacingFactor <= maxHeight;
+function fitsAt(text22, maxWidth, maxHeight, size, table2, lineSpacingFactor) {
+  return wrappedLineCount(text22, maxWidth, size, table2) * size * table2.lineHeightRatio * lineSpacingFactor <= maxHeight;
 }
-function fitWrappedFontSize(text22, maxWidth, maxHeight, ceiling, floor, table = DEFAULT_FONT_ADVANCE_TABLE, lineSpacingFactor = SMARTART_LINE_SPACING_FACTOR) {
+function fitWrappedFontSize(text22, maxWidth, maxHeight, ceiling, floor, table2 = DEFAULT_FONT_ADVANCE_TABLE, lineSpacingFactor = SMARTART_LINE_SPACING_FACTOR) {
   if (text22.trim().length === 0 || maxWidth <= 0 || maxHeight <= 0) {
     return ceiling;
   }
-  if (fitsAt(text22, maxWidth, maxHeight, ceiling, table, lineSpacingFactor)) {
+  if (fitsAt(text22, maxWidth, maxHeight, ceiling, table2, lineSpacingFactor)) {
     return ceiling;
   }
-  if (!fitsAt(text22, maxWidth, maxHeight, floor, table, lineSpacingFactor)) {
+  if (!fitsAt(text22, maxWidth, maxHeight, floor, table2, lineSpacingFactor)) {
     return floor;
   }
   let lo = floor;
   let hi = ceiling;
   for (let i2 = 0; i2 < BINARY_SEARCH_ITERATIONS; i2++) {
     const mid = (lo + hi) / 2;
-    if (fitsAt(text22, maxWidth, maxHeight, mid, table, lineSpacingFactor)) {
+    if (fitsAt(text22, maxWidth, maxHeight, mid, table2, lineSpacingFactor)) {
       lo = mid;
     } else {
       hi = mid;
@@ -35308,15 +35399,15 @@ var init_smartart_text_wrap_fit = __esm({
 function resolveFontTable(fontName) {
   return FONT_ADVANCE_TABLES[fontName ?? "Calibri"] ?? DEFAULT_FONT_ADVANCE_TABLE;
 }
-function itemMarginsPx(index, role, table) {
+function itemMarginsPx(index, role, table2) {
   const left = resolveConstraint(index, role, "lMarg");
   const right = resolveConstraint(index, role, "rMarg");
   const top = resolveConstraint(index, role, "tMarg");
   const bottom = resolveConstraint(index, role, "bMarg");
-  const leftPt = typeof left === "number" ? left : table.marginLeftPt;
-  const rightPt = typeof right === "number" ? right : table.marginRightPt;
-  const topPt = typeof top === "number" ? top : table.marginTopPt;
-  const bottomPt = typeof bottom === "number" ? bottom : table.marginBottomPt;
+  const leftPt = typeof left === "number" ? left : table2.marginLeftPt;
+  const rightPt = typeof right === "number" ? right : table2.marginRightPt;
+  const topPt = typeof top === "number" ? top : table2.marginTopPt;
+  const bottomPt = typeof bottom === "number" ? bottom : table2.marginBottomPt;
   return {
     horizontal: (leftPt + rightPt) * POINTS_TO_PIXELS3,
     vertical: (topPt + bottomPt) * POINTS_TO_PIXELS3
@@ -35360,8 +35451,8 @@ function fitSharedFontSize(bounds, index, items, fontName, naturalAspect) {
   if (items.length === 0) {
     return snapToWholePoint(ceilingPx);
   }
-  const table = resolveFontTable(fontName);
-  const fixedMargins = itemMarginsPx(index, role, table);
+  const table2 = resolveFontTable(fontName);
+  const fixedMargins = itemMarginsPx(index, role, table2);
   const proportional = proportionalMarginFraction(index, role);
   const lineSpacingFactor = SMARTART_LINE_SPACING_FACTOR;
   const fitAtMarginBasis = (marginBasisPx) => {
@@ -35380,7 +35471,7 @@ function fitSharedFontSize(bounds, index, items, fontName, naturalAspect) {
         availableHeight,
         ceilingPx,
         floorPx,
-        table,
+        table2,
         lineSpacingFactor
       );
       shared2 = Math.min(shared2, fit);
@@ -35417,15 +35508,15 @@ function isMainAxisContentSized(index, arrangerRole, itemRole, mainAxisType) {
   const raw = firstConstraintDeclaredBy(index, itemRole, mainAxisType, arrangerRole);
   return raw !== void 0 && raw.value === Number.POSITIVE_INFINITY && !hasReference(raw);
 }
-function resolveContentSizedExtents(texts, crossExtentPx, fontSizePx2, table, lineSpacingFactor, fontRole, index, cornerInsetPx, usableMain, gap) {
+function resolveContentSizedExtents(texts, crossExtentPx, fontSizePx2, table2, lineSpacingFactor, fontRole, index, cornerInsetPx, usableMain, gap) {
   const margins = proportionalMarginFraction(index, fontRole);
-  const marginVerticalPx = margins ? margins.vertical * fontSizePx2 : itemMarginsPx(index, fontRole, table).vertical;
+  const marginVerticalPx = margins ? margins.vertical * fontSizePx2 : itemMarginsPx(index, fontRole, table2).vertical;
   const availWidthPx = Math.max(1, crossExtentPx - 2 * cornerInsetPx);
   const natural = texts.map((text22) => {
-    const lines = Math.max(1, wrappedLineCount(text22, availWidthPx, fontSizePx2, table));
+    const lines = Math.max(1, wrappedLineCount(text22, availWidthPx, fontSizePx2, table2));
     return Math.max(
       12,
-      lines * fontSizePx2 * table.lineHeightRatio * lineSpacingFactor + marginVerticalPx + 2 * cornerInsetPx
+      lines * fontSizePx2 * table2.lineHeightRatio * lineSpacingFactor + marginVerticalPx + 2 * cornerInsetPx
     );
   });
   const n = natural.length;
@@ -36174,16 +36265,16 @@ function paragraphBlockPx(lines, sizePx2, ratio, lineSpacingFactor, spcAftFactor
   const content = lines * sizePx2 * ratio * lineSpacingFactor;
   return isLastParagraph ? content : content + spcAftFactor * sizePx2 * ratio;
 }
-function itemFits(item, availWidthPx, availHeightPx, rootPx, descendantPx, table, lineSpacingFactor) {
+function itemFits(item, availWidthPx, availHeightPx, rootPx, descendantPx, table2, lineSpacingFactor) {
   const hasDescendants = item.descendantTexts.length > 0;
-  if (wrappedWidestLineWidth(item.rootText, availWidthPx, rootPx, table) > availWidthPx) {
+  if (wrappedWidestLineWidth(item.rootText, availWidthPx, rootPx, table2) > availWidthPx) {
     return false;
   }
-  const rootLines = wrappedLineCount(item.rootText, availWidthPx, rootPx, table);
+  const rootLines = wrappedLineCount(item.rootText, availWidthPx, rootPx, table2);
   let totalPx = paragraphBlockPx(
     rootLines,
     rootPx,
-    table.lineHeightRatio,
+    table2.lineHeightRatio,
     lineSpacingFactor,
     ROOT_SPCAFT_FACTOR,
     !hasDescendants || item.separateDescendantBox === true
@@ -36193,14 +36284,14 @@ function itemFits(item, availWidthPx, availHeightPx, rootPx, descendantPx, table
   for (let i2 = 0; i2 < item.descendantTexts.length; i2++) {
     const isLast = i2 === item.descendantTexts.length - 1;
     const text22 = item.descendantTexts[i2];
-    if (wrappedWidestLineWidth(text22, descendantWidthPx, descendantPx, table) > descendantWidthPx) {
+    if (wrappedWidestLineWidth(text22, descendantWidthPx, descendantPx, table2) > descendantWidthPx) {
       return false;
     }
-    const lines = wrappedLineCount(text22, descendantWidthPx, descendantPx, table);
+    const lines = wrappedLineCount(text22, descendantWidthPx, descendantPx, table2);
     totalPx += paragraphBlockPx(
       lines,
       descendantPx,
-      table.lineHeightRatio,
+      table2.lineHeightRatio,
       lineSpacingFactor,
       DESCENDANT_SPCAFT_FACTOR,
       isLast
@@ -36232,8 +36323,8 @@ function resolveTieredItemFontSize(plan, index, items, fontName, naturalAspect,
   if (items.length === 0) {
     return { rootSizePx: ceilingPx, descendantSizePx: ceilingPx * SMARTART_DESCENDANT_FONT_SCALE };
   }
-  const table = resolveFontTable(fontName);
-  const fixedMargins = itemMarginsPx(index, role, table);
+  const table2 = resolveFontTable(fontName);
+  const fixedMargins = itemMarginsPx(index, role, table2);
   const proportional = proportionalMarginFraction(index, role);
   const lineSpacingFactor = SMARTART_LINE_SPACING_FACTOR;
   const fitsAtMarginBasis = (rootPx2, marginBasisPx) => {
@@ -36253,7 +36344,7 @@ function resolveTieredItemFontSize(plan, index, items, fontName, naturalAspect,
         availHeightPx,
         rootPx2,
         descendantPx,
-        table,
+        table2,
         lineSpacingFactor
       );
       if (!fits) {
@@ -36311,6 +36402,152 @@ var init_smartart_layout_item_font_tier = __esm({
     PX_PER_PT2 = 96 / 72;
   }
 });
+function algTypeOf(node, nodeCount, presLayoutVars) {
+  return node.algorithm?.type ?? chooseAlgType(node, nodeCount, { presLayoutVars: presLayoutVars ?? {} });
+}
+function findRowChild(node, presLayoutVars) {
+  return (node.children ?? []).find((child262) => {
+    if (child262.algorithm?.type === "sp") {
+      return false;
+    }
+    if (algTypeOf(child262, 2, presLayoutVars) !== "lin") {
+      return false;
+    }
+    return (child262.children ?? []).some(
+      (grandchild) => grandchild.forEachOrigin?.axis?.includes("ch") && grandchild.forEachOrigin?.pointTypes?.includes("node")
+    );
+  });
+}
+function isRecursiveTableItemTemplate(node, presLayoutVars) {
+  if (!node.forEachOrigin?.axis?.includes("ch") || !node.forEachOrigin?.pointTypes?.includes("node")) {
+    return false;
+  }
+  if (algTypeOf(node, 2, presLayoutVars) !== "lin") {
+    return false;
+  }
+  const hasLabel = (node.children ?? []).some(
+    (child262) => child262.algorithm?.type === "tx" && child262.presentationOf?.axis?.includes("self")
+  );
+  return hasLabel && findRowChild(node, presLayoutVars) !== void 0;
+}
+function resolvedLinDir(node, nodeCount, presLayoutVars, fallback) {
+  const alg = node.algorithm ?? chooseAlgorithm(node, nodeCount, { presLayoutVars: presLayoutVars ?? {} });
+  return alg?.parameters?.find((p) => p.type === "linDir")?.value ?? fallback;
+}
+function arrangeRecursiveTable(plan, nodes, box, palette, style, elementId, index, childrenOf, fontName, presLayoutVars) {
+  const ctx = styleContext(style);
+  const { width: w, height: h2 } = box;
+  const reversed = resolvedLinDir(plan.node, nodes.length, presLayoutVars, "fromT") === "fromB";
+  const rowChild = findRowChild(plan.node, presLayoutVars);
+  const colReversed = rowChild ? resolvedLinDir(rowChild, nodes.length, presLayoutVars, "fromL") === "fromR" : false;
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const childrenIn = (n) => (childrenOf.get(n.id) ?? []).filter((c) => byId.has(c.id));
+  const childIds = /* @__PURE__ */ new Set();
+  for (const n of nodes) {
+    for (const c of childrenIn(n)) {
+      childIds.add(c.id);
+    }
+  }
+  const roots = nodes.filter((n) => !childIds.has(n.id));
+  const depthOf = /* @__PURE__ */ new Map();
+  let maxDepth = 0;
+  const depthStack = roots.map((r) => ({
+    node: r,
+    depth: 0
+  }));
+  while (depthStack.length > 0) {
+    const { node, depth } = depthStack.pop();
+    depthOf.set(node.id, depth);
+    maxDepth = Math.max(maxDepth, depth);
+    for (const c of childrenIn(node)) {
+      depthStack.push({ node: c, depth: depth + 1 });
+    }
+  }
+  const generations = maxDepth + 1;
+  const rowDenom = generations + Math.max(0, generations - 1) * DEFAULT_GAP_RATIO;
+  const rowHeight = h2 / rowDenom;
+  const rowGap = DEFAULT_GAP_RATIO * rowHeight;
+  const rowY = (depth) => (reversed ? generations - 1 - depth : depth) * (rowHeight + rowGap);
+  const splitAcross = (items, x, width) => {
+    const n = items.length;
+    if (n === 0) {
+      return [];
+    }
+    const denom = n + Math.max(0, n - 1) * DEFAULT_GAP_RATIO;
+    const colWidth = width / denom;
+    const colGap = DEFAULT_GAP_RATIO * colWidth;
+    const ordered4 = colReversed ? [...items].reverse() : items;
+    const out = [];
+    let cursor = x;
+    for (const item of ordered4) {
+      out.push([item, cursor, colWidth]);
+      cursor += colWidth + colGap;
+    }
+    return out;
+  };
+  const placed = [];
+  const place = (node, x, width) => {
+    placed.push({ node, x, width });
+    const kids = childrenIn(node);
+    for (const [child262, childX, childWidth] of splitAcross(kids, x, width)) {
+      place(child262, childX, childWidth);
+    }
+  };
+  for (const [root, rootX, rootWidth] of splitAcross(roots, 0, w)) {
+    place(root, rootX, rootWidth);
+  }
+  const itemShape = findCompositeItemShape(plan.node);
+  const { rootSizePx: fontSizeOverride, descendantSizePx } = resolveTieredItemFontSize(
+    plan,
+    index,
+    placed.map(({ node, width }) => ({
+      rootText: node.text,
+      descendantTexts: [],
+      width,
+      height: rowHeight,
+      separateDescendantBox: false
+    })),
+    fontName,
+    void 0
+  );
+  const renderedNodes = placed.map(
+    ({ node, x, width }, i2) => presetBoxNode({
+      key: `${elementId}-lintbl-${node.id}-${i2}`,
+      x,
+      y: rowY(depthOf.get(node.id) ?? 0),
+      width,
+      height: rowHeight,
+      node,
+      index: i2,
+      total: placed.length,
+      palette,
+      style,
+      ctx,
+      shape: itemShape,
+      fallbackKind: "rect",
+      fontSizeOverride,
+      descendantFontSize: descendantSizePx
+    })
+  );
+  return {
+    nodes: renderedNodes,
+    connectors: [],
+    shadowFilter: ctx.shadow,
+    viewBox: `0 0 ${w} ${h2}`,
+    family: "list"
+  };
+}
+var DEFAULT_GAP_RATIO;
+var init_smartart_layout_interpreter_linear_table = __esm({
+  "src/core/utils/smartart-layout-interpreter-linear-table.ts"() {
+    init_smartart_layout_interpreter_choose_algorithm();
+    init_smartart_layout_interpreter_preset_node();
+    init_smartart_layout_interpreter_render();
+    init_smartart_layout_item_font_tier();
+    init_smartart_layout_shape_preset();
+    DEFAULT_GAP_RATIO = 0.25;
+  }
+});
 function snakeGridDims(plan, n, w, h2, flowDir) {
   const bkpt = algorithmParam(plan.node, "bkpt");
   const fixedVal = findConstraint(plan.node.constraints, "bkPtFixedVal")?.value;
@@ -36467,6 +36704,20 @@ var init_smartart_layout_interpreter_snake = __esm({
   }
 });
 function arrangeLinear(plan, flow, nodes, box, palette, style, elementId, index = EMPTY_CONSTRAINT_INDEX, childrenOf, fontName, presLayoutVars) {
+  if (childrenOf && isRecursiveTableItemTemplate(plan.node, presLayoutVars)) {
+    return arrangeRecursiveTable(
+      plan,
+      nodes,
+      box,
+      palette,
+      style,
+      elementId,
+      index,
+      childrenOf,
+      fontName,
+      presLayoutVars
+    );
+  }
   const { width: w, height: h2 } = box;
   const ctx = styleContext(style);
   const constraints = plan.node.constraints;
@@ -36577,6 +36828,7 @@ var init_smartart_layout_interpreter_linear = __esm({
     init_smartart_layout_interpreter_linear_item_aspect();
     init_smartart_layout_interpreter_linear_main_axis();
     init_smartart_layout_interpreter_linear_shared();
+    init_smartart_layout_interpreter_linear_table();
     init_smartart_layout_interpreter_model();
     init_smartart_layout_interpreter_preset_node();
     init_smartart_layout_interpreter_render();
@@ -36697,20 +36949,23 @@ function isCrossRoleReference(constraint) {
   return (constraint.referenceFor === "ch" || constraint.referenceFor === "des") && Boolean(constraint.referenceForName);
 }
 function dimDeclaredBy(role, type, declaringRole, box, index) {
-  const declared = firstConstraintDeclaredBy(index, role, type, declaringRole);
-  if (!declared) {
-    return void 0;
-  }
-  const resolved = resolveConstraintDeclaredBy(index, role, type, declaringRole);
-  if (typeof resolved !== "number" || !Number.isFinite(resolved)) {
-    return void 0;
-  }
-  const extent = axisExtent(declared.referenceType, box, defaultExtent(type, box));
-  if (resolved >= 0 && resolved <= 1) {
-    return { px: resolved * extent };
-  }
-  if (resolved > 1) {
-    return { abs: resolved };
+  const chain = typeof declaringRole === "string" ? [declaringRole] : declaringRole;
+  for (const candidateRole of chain) {
+    const declared = firstConstraintDeclaredBy(index, role, type, candidateRole);
+    if (!declared) {
+      continue;
+    }
+    const resolved = resolveConstraintDeclaredBy(index, role, type, candidateRole);
+    if (typeof resolved !== "number" || !Number.isFinite(resolved)) {
+      continue;
+    }
+    const extent = axisExtent(declared.referenceType, box, defaultExtent(type, box));
+    if (resolved >= 0 && resolved <= 1) {
+      return { px: resolved * extent };
+    }
+    if (resolved > 1) {
+      return { abs: resolved };
+    }
   }
   return void 0;
 }
@@ -36742,6 +36997,13 @@ function dimOf(constraints, type, box, index, role, declaringRole) {
   }
   return void 0;
 }
+var init_smartart_layout_interpreter_composite_slot_dim = __esm({
+  "src/core/utils/smartart-layout-interpreter-composite-slot-dim.ts"() {
+    init_smartart_constraint_declared_by();
+    init_smartart_constraint_solver();
+    init_smartart_layout_interpreter_model();
+  }
+});
 function isPositioned(dims) {
   return dims.l !== void 0 || dims.t !== void 0 || dims.w !== void 0 || dims.h !== void 0 || dims.ctrX !== void 0 || dims.ctrY !== void 0;
 }
@@ -36830,9 +37092,8 @@ function resolveSlot(dims, box, absX, absY) {
 }
 var init_smartart_layout_interpreter_composite_slots = __esm({
   "src/core/utils/smartart-layout-interpreter-composite-slots.ts"() {
-    init_smartart_constraint_declared_by();
     init_smartart_constraint_solver();
-    init_smartart_layout_interpreter_model();
+    init_smartart_layout_interpreter_composite_slot_dim();
   }
 });
 function childAxisSpec(template, childCount) {
@@ -36953,6 +37214,23 @@ function resolveAnchoredContentPerAnchor(node, flat) {
   }
   return groups;
 }
+function resolveAnchoredContentPerAnchorFrom(node, flat, origin) {
+  const presOf = resolvePresentationOf(node, flat);
+  if (!presOf?.axis || presOf.axis.length === 0 || !origin.axis || origin.axis.length === 0) {
+    return [];
+  }
+  const anchors = resolveAxisNodes(flat, origin.axis, origin.pointTypes, origin.start, origin.count) ?? [];
+  const anchorCount = anchors.length;
+  const presOfAxis = presOf.axis;
+  const groups = [];
+  anchors.forEach((anchor, anchorIndex) => {
+    const content = resolveAxisNodes(flat, presOfAxis, presOf.pointTypes, presOf.start, presOf.count, [anchor]) ?? [];
+    if (content.length > 0) {
+      groups.push({ content, anchorIndex, anchorCount });
+    }
+  });
+  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();
@@ -36962,8 +37240,10 @@ var init_smartart_layout_interpreter_composite_anchor = __esm({
 function winningOrdinalFor(guardsByOrdinal, nodeCount, flat) {
   const ordinals = [...guardsByOrdinal.keys()].sort((a, b) => a - b);
   for (const ordinal of ordinals) {
-    const guard = guardsByOrdinal.get(ordinal);
-    const allows = !guard || evaluateWhen(guard, nodeCount, { nodes: flat }) !== false;
+    const entry2 = guardsByOrdinal.get(ordinal);
+    const origin = entry2?.forEachOrigin;
+    const anchor = origin?.axis && origin.axis.length > 0 ? resolveAxisNodes(flat, origin.axis, origin.pointTypes, origin.start, origin.count) : void 0;
+    const allows = !entry2?.guard || evaluateWhen(entry2.guard, nodeCount, { nodes: flat, anchor }) !== false;
     if (allows) {
       return ordinal;
     }
@@ -36983,7 +37263,7 @@ function selectFirstMatchChildren(children12, flat) {
         guardsByGroup.set(entry2.id, byOrdinal);
       }
       if (!byOrdinal.has(entry2.ordinal)) {
-        byOrdinal.set(entry2.ordinal, entry2.guard);
+        byOrdinal.set(entry2.ordinal, { guard: entry2.guard, forEachOrigin: child262.forEachOrigin });
       }
     }
   }
@@ -37001,9 +37281,149 @@ function selectFirstMatchChildren(children12, flat) {
 }
 var init_smartart_layout_interpreter_composite_choose_groups = __esm({
   "src/core/utils/smartart-layout-interpreter-composite-choose-groups.ts"() {
+    init_smartart_layout_interpreter_axis_count();
     init_smartart_layout_interpreter_when();
   }
 });
+function resolveOwnAnchor(node, flat) {
+  const origin = node.forEachOrigin;
+  if (!origin?.axis || origin.axis.length === 0) {
+    return void 0;
+  }
+  return resolveAxisNodes(flat, origin.axis, origin.pointTypes, origin.start, origin.count);
+}
+function guardAllows(node, flat, iterationPosition) {
+  if (!node.chooseGuard) {
+    return true;
+  }
+  const anchor = resolveOwnAnchor(node, flat);
+  return node.chooseGuard.every(
+    (guard) => evaluateWhen(guard, flat.length, {
+      nodes: flat,
+      anchor,
+      position: iterationPosition?.position,
+      total: iterationPosition?.total
+    }) !== false
+  );
+}
+function collectRawCandidates(node, flat, declaringRole, out = [], inheritedOrigin, ancestorChain = []) {
+  const hasPresOf = (node.presentationOf?.axis?.length ?? 0) > 0 || (node.presentationOfCandidates?.length ?? 0) > 0;
+  if (hasPresOf) {
+    const ownOrigin = (node.forEachOrigin?.axis?.length ?? 0) > 0 ? node.forEachOrigin : void 0;
+    if (!ownOrigin && inheritedOrigin) {
+      const declaringRoleChain = ancestorChain.length > 0 ? [declaringRole, ...ancestorChain] : void 0;
+      for (const { content, anchorIndex, anchorCount } of resolveAnchoredContentPerAnchorFrom(
+        node,
+        flat,
+        inheritedOrigin
+      )) {
+        const iterationPosition2 = anchorCount > 1 ? { position: anchorIndex + 1, total: anchorCount } : void 0;
+        if (!guardAllows(node, flat, iterationPosition2)) {
+          continue;
+        }
+        out.push({
+          node,
+          declaringRole,
+          declaringRoleChain,
+          content,
+          iteration: anchorIndex,
+          iterationCount: anchorCount
+        });
+      }
+      return out;
+    }
+    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);
+  const nextAncestorChain = nextRole === declaringRole ? ancestorChain : [declaringRole, ...ancestorChain];
+  const ownTemplateOrigin = node.algorithm?.type && STRUCTURAL_ALG_TYPES.has(node.algorithm.type) && node.forEachOrigin?.axis?.includes("ch") && node.forEachOrigin?.pointTypes?.includes("node") ? node.forEachOrigin : void 0;
+  const effectiveOrigin = ownTemplateOrigin ?? inheritedOrigin;
+  for (const child262 of selectFirstMatchChildren(node.children ?? [], flat)) {
+    collectRawCandidates(child262, flat, nextRole, out, effectiveOrigin, nextAncestorChain);
+  }
+  return out;
+}
+var init_smartart_layout_interpreter_composite_candidates = __esm({
+  "src/core/utils/smartart-layout-interpreter-composite-candidates.ts"() {
+    init_smartart_constraint_solver();
+    init_smartart_layout_interpreter_axis_count();
+    init_smartart_layout_interpreter_composite_anchor();
+    init_smartart_layout_interpreter_composite_choose_groups();
+    init_smartart_layout_interpreter_composite_detect();
+    init_smartart_layout_interpreter_when();
+  }
+});
+function resolveSharedFontFit(fontCtx, fontRoleNode, items) {
+  if (items.length === 0) {
+    return void 0;
+  }
+  return resolveTieredItemFontSize(
+    fontCtx.plan,
+    fontCtx.index,
+    items,
+    fontCtx.fontName,
+    void 0,
+    0,
+    fontRoleNode
+  );
+}
+function resolveFontFitFromPairs(fontCtx, fontRoleNode, pairs3) {
+  if (!fontCtx) {
+    return void 0;
+  }
+  return resolveSharedFontFit(
+    fontCtx,
+    fontRoleNode,
+    pairs3.map((pair) => ({
+      rootText: pair.node.text,
+      descendantTexts: pair.desSlot?.content.map((entry2) => entry2.text) ?? [],
+      width: pair.selfRect.width,
+      height: pair.selfRect.height
+    }))
+  );
+}
+function resolveFitByDeclaringRole(fontCtx, slots) {
+  const byRole = /* @__PURE__ */ new Map();
+  for (const slot of slots) {
+    const group2 = byRole.get(slot.declaringRole);
+    if (group2) {
+      group2.push(slot);
+    } else {
+      byRole.set(slot.declaringRole, [slot]);
+    }
+  }
+  const fitByRole = /* @__PURE__ */ new Map();
+  for (const [role, group2] of byRole) {
+    const fit = resolveSharedFontFit(
+      fontCtx,
+      group2[0]?.node,
+      group2.map(({ content, rect: rect22 }) => ({
+        rootText: content[0]?.text ?? "",
+        descendantTexts: content.slice(1).map((entry2) => entry2.text),
+        width: rect22.width,
+        height: rect22.height
+      }))
+    );
+    fitByRole.set(role, fit);
+  }
+  return fitByRole;
+}
+var init_smartart_layout_interpreter_composite_fontfit = __esm({
+  "src/core/utils/smartart-layout-interpreter-composite-fontfit.ts"() {
+    init_smartart_layout_item_font_tier();
+  }
+});
 function resolveIterationRect(dims, box, iteration, iterationCount) {
   const container = resolveSlot(dims, box, 1, 1);
   if (iterationCount <= 1) {
@@ -37043,7 +37463,12 @@ function resolveGroupedSlots(candidates, box, index) {
       return aIsSp - bIsSp;
     });
     for (const candidate of ordered4) {
-      const [slotted] = readSlots([candidate.node], box, index, candidate.declaringRole);
+      const [slotted] = readSlots(
+        [candidate.node],
+        box,
+        index,
+        candidate.declaringRoleChain ?? candidate.declaringRole
+      );
       if (slotted) {
         const rect22 = resolveIterationRect(
           slotted.dims,
@@ -37051,7 +37476,12 @@ function resolveGroupedSlots(candidates, box, index) {
           candidate.iteration,
           candidate.iterationCount
         );
-        out.push({ rect: rect22, content: candidate.content, node: candidate.node });
+        out.push({
+          rect: rect22,
+          content: candidate.content,
+          node: candidate.node,
+          declaringRole: candidate.declaringRole
+        });
         break;
       }
     }
@@ -37064,51 +37494,19 @@ var init_smartart_layout_interpreter_composite_group_slots = __esm({
     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 hasPresOf = (node.presentationOf?.axis?.length ?? 0) > 0 || (node.presentationOfCandidates?.length ?? 0) > 0;
-  if (hasPresOf) {
-    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 selectFirstMatchChildren(node.children ?? [], flat)) {
-    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);
 }
-function arrangeByChooseAwareSlots(root, flat, box, index, ctx) {
+function arrangeByChooseAwareSlots(root, flat, box, index, ctx, fontCtx) {
   const slots = collectChooseAwareSlots(root, flat, box, index, roleOf(root));
   if (slots.length === 0) {
     return void 0;
   }
-  return slots.map(({ rect: rect22, content, node: layoutNode }, i2) => {
+  const fitByRole = fontCtx ? resolveFitByDeclaringRole(fontCtx, slots) : /* @__PURE__ */ new Map();
+  return slots.map(({ rect: rect22, content, node: layoutNode, declaringRole }, i2) => {
     const first = content[0];
+    const fit = fitByRole.get(declaringRole);
     const rendered = {
       ...presetBoxNode({
         key: `${ctx.elementId}-comp-choose-${first.id}-${i2}`,
@@ -37121,6 +37519,8 @@ function arrangeByChooseAwareSlots(root, flat, box, index, ctx) {
         total: slots.length,
         palette: ctx.palette,
         style: ctx.style,
+        fontSizeOverride: fit?.rootSizePx,
+        descendantFontSize: fit?.descendantSizePx,
         ctx: ctx.ctx,
         shape: findCompositeItemShape(layoutNode),
         fallbackKind: "rect"
@@ -37133,48 +37533,13 @@ function arrangeByChooseAwareSlots(root, flat, box, index, ctx) {
 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_choose_groups();
+    init_smartart_layout_interpreter_composite_candidates();
+    init_smartart_layout_interpreter_composite_fontfit();
     init_smartart_layout_interpreter_composite_group_slots();
     init_smartart_layout_interpreter_preset_node();
-    init_smartart_layout_interpreter_when();
     init_smartart_layout_shape_preset();
   }
 });
-function resolveSharedFontFit(fontCtx, fontRoleNode, items) {
-  if (items.length === 0) {
-    return void 0;
-  }
-  return resolveTieredItemFontSize(
-    fontCtx.plan,
-    fontCtx.index,
-    items,
-    fontCtx.fontName,
-    void 0,
-    0,
-    fontRoleNode
-  );
-}
-function resolveFontFitFromPairs(fontCtx, fontRoleNode, pairs3) {
-  if (!fontCtx) {
-    return void 0;
-  }
-  return resolveSharedFontFit(
-    fontCtx,
-    fontRoleNode,
-    pairs3.map((pair) => ({
-      rootText: pair.node.text,
-      descendantTexts: pair.desSlot?.content.map((entry2) => entry2.text) ?? [],
-      width: pair.selfRect.width,
-      height: pair.selfRect.height
-    }))
-  );
-}
-var init_smartart_layout_interpreter_composite_fontfit = __esm({
-  "src/core/utils/smartart-layout-interpreter-composite-fontfit.ts"() {
-    init_smartart_layout_item_font_tier();
-  }
-});
 function forEachBoundSlots(slotted) {
   return slotted.filter((slot) => {
     const axis = slot.node.presentationOf?.axis;
@@ -37459,7 +37824,7 @@ function arrangeComposite(plan, nodes, box, palette, style, elementId, index = E
     childrenOf,
     ctx,
     fontCtx
-  ) ?? arrangeByChooseAwareSlots(plan.node, flat, box, index, ctx) ?? arrangeByOrder(slotted, nodes, box, absX, absY, ctx, fontCtx);
+  ) ?? arrangeByChooseAwareSlots(plan.node, flat, box, index, ctx, fontCtx) ?? arrangeByOrder(slotted, nodes, box, absX, absY, ctx, fontCtx);
   return {
     nodes: renderedNodes,
     connectors: [],
@@ -37979,7 +38344,7 @@ function arrangePyramid(plan, nodes, box, palette, style, elementId, index = EMP
     index,
     roleOf(plan.node),
     ["sibSp", "sp"],
-    DEFAULT_GAP_RATIO
+    DEFAULT_GAP_RATIO2
   );
   const usableH = h2 - DEFAULT_INSET * 2;
   const bandH = n > 0 ? usableH / (n + Math.max(0, n - 1) * gapRatio) : usableH;
@@ -38051,7 +38416,7 @@ function arrangePyramid(plan, nodes, box, palette, style, elementId, index = EMP
     family: "pyramid"
   };
 }
-var DEFAULT_GAP_RATIO;
+var DEFAULT_GAP_RATIO2;
 var DEFAULT_INSET;
 var init_smartart_layout_interpreter_pyramid = __esm({
   "src/core/utils/smartart-layout-interpreter-pyramid.ts"() {
@@ -38061,7 +38426,7 @@ var init_smartart_layout_interpreter_pyramid = __esm({
     init_smartart_layout_interpreter_model();
     init_smartart_layout_interpreter_render();
     init_smartart_layout_item_font_tier();
-    DEFAULT_GAP_RATIO = 0;
+    DEFAULT_GAP_RATIO2 = 0;
     DEFAULT_INSET = 0;
   }
 });
@@ -38243,26 +38608,67 @@ var init_smartart_hierarchy_pitch = __esm({
     GENERATION_MARGIN_RATIO = 0.1675;
   }
 });
-function findHierarchyItemNode(node) {
+function collectTxShapeNodes(node, out, seen) {
   if (!node) {
-    return void 0;
+    return;
   }
   if (node.algorithm?.type === "tx" && node.shape) {
-    return node;
+    const key2 = node.name ?? `#${out.length}`;
+    if (!seen.has(key2)) {
+      seen.add(key2);
+      out.push(node);
+    }
   }
   for (const child262 of node.children ?? []) {
-    const found = findHierarchyItemNode(child262);
-    if (found) {
-      return found;
+    collectTxShapeNodes(child262, out, seen);
+  }
+}
+function crossReferencesAnotherCandidate(candidate, otherNames, constraints) {
+  const candidateName = candidate.name;
+  if (!candidateName) {
+    return false;
+  }
+  return (constraints ?? []).some(
+    (c) => (c.type === "h" || c.type === "w") && c.for === "des" && c.forName === candidateName && c.referenceForName !== void 0 && c.referenceForName !== candidateName && otherNames.has(c.referenceForName)
+  );
+}
+function resolveHierarchyItemNode(algorithmNode) {
+  if (!algorithmNode) {
+    return void 0;
+  }
+  const candidates = [];
+  collectTxShapeNodes(algorithmNode, candidates, /* @__PURE__ */ new Set());
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  const first = candidates[0];
+  if (candidates.length < 2 || !first) {
+    return first;
+  }
+  const allNames = new Set(
+    candidates.map((c) => c.name).filter((n) => n !== void 0)
+  );
+  const constraints = algorithmNode.allConstraints ?? algorithmNode.constraints ?? [];
+  for (const candidate of candidates) {
+    const otherNames = new Set(allNames);
+    if (candidate.name) {
+      otherNames.delete(candidate.name);
+    }
+    if (crossReferencesAnotherCandidate(candidate, otherNames, constraints)) {
+      return candidate;
     }
   }
-  return void 0;
+  return first;
 }
+var init_smartart_hierarchy_item_template = __esm({
+  "src/core/utils/smartart-hierarchy-item-template.ts"() {
+  }
+});
 function findHierarchyItemShape(node) {
-  return findHierarchyItemNode(node)?.shape;
+  return resolveHierarchyItemNode(node)?.shape;
 }
 function findHierarchyItemName(node) {
-  return findHierarchyItemNode(node)?.name;
+  return resolveHierarchyItemNode(node)?.name;
 }
 function baseContext(nodeCount, elementId, palette, style, boxW, boxH, connectorLabels, itemShape, itemFontSizePx) {
   return {
@@ -38323,6 +38729,7 @@ var HIER_TAIL_OFFSET_RATIO;
 var HANG_HEIGHT_RATIO;
 var init_smartart_hierarchy_shared = __esm({
   "src/core/utils/smartart-hierarchy-shared.ts"() {
+    init_smartart_hierarchy_item_template();
     init_smartart_layout_interpreter_preset_node();
     init_smartart_layout_interpreter_render();
     HIER_TAIL_OFFSET_RATIO = 0.25;
@@ -38330,9 +38737,11 @@ var init_smartart_hierarchy_shared = __esm({
   }
 });
 function computeHierarchyAxisPitches(effectiveBox, orientation, boxW, boxH, totalLeaves, depth, hangShape, tailedPitch) {
+  const generationItemSize = tailedPitch && orientation.compositeHeightFactor ? boxH / orientation.compositeHeightFactor : boxH;
   const generationMargin = orientation.transposed ? 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.maxHangRows * (1 + HANG_HEIGHT_RATIO) * boxH : effectiveBox.height;
+  const hangHeightRatio = orientation.transposed ? orientation.generationGapRatio : HANG_HEIGHT_RATIO;
+  const fanHeight = tailedPitch ? effectiveBox.height - hangShape.maxHangRows * (1 + hangHeightRatio) * boxH : effectiveBox.height;
   const xPitch = compositeFanPitch(
     fanWidth,
     boxW,
@@ -38345,7 +38754,7 @@ function computeHierarchyAxisPitches(effectiveBox, orientation, boxW, boxH, tota
   const yPitch = computeAxisPitch(
     fanHeight,
     generationMargin,
-    boxH,
+    generationItemSize,
     depth,
     fixedGenerationGapRatio
   );
@@ -38391,6 +38800,27 @@ var init_smartart_hierarchy_branch_mode = __esm({
   "src/core/utils/smartart-hierarchy-branch-mode.ts"() {
   }
 });
+function resolveCascadePlan(mode, orientation, depth, hangShape, boxW) {
+  const active = mode === "tailed" && orientation.compositeHeightFactor !== void 0;
+  if (!active) {
+    return { active, pitchDepth: depth, pitchHangShape: hangShape };
+  }
+  return {
+    active,
+    pitchDepth: depth + hangShape.maxHangRows,
+    pitchHangShape: { ...hangShape, maxHangRows: 0 },
+    cascadeOffsetX: {
+      fromLevel: depth,
+      offsetPx: boxW / (orientation.compositeWidthFactor ?? 1) * CASCADE_ALIGN_OFF_RATIO
+    }
+  };
+}
+var CASCADE_ALIGN_OFF_RATIO;
+var init_smartart_hierarchy_cascade = __esm({
+  "src/core/utils/smartart-hierarchy-cascade.ts"() {
+    CASCADE_ALIGN_OFF_RATIO = 0.65;
+  }
+});
 function isAssistant(node) {
   return node.nodeType === "asst";
 }
@@ -38588,6 +39018,36 @@ var init_smartart_hierarchy_fold_depth = __esm({
   "src/core/utils/smartart-hierarchy-fold-depth.ts"() {
   }
 });
+function resolveHierarchyItemFontSizePx(nodes, algorithmNode, index, boxW, boxH, fontName) {
+  if (!algorithmNode) {
+    return void 0;
+  }
+  const textNodes = nodes.filter((node) => node.text && node.text.trim().length > 0);
+  if (textNodes.length === 0) {
+    return void 0;
+  }
+  const plan = { node: algorithmNode };
+  const { rootSizePx } = resolveTieredItemFontSize(
+    plan,
+    index,
+    textNodes.map((node) => ({
+      rootText: node.text,
+      descendantTexts: [],
+      width: boxW,
+      height: boxH
+    })),
+    fontName,
+    void 0,
+    0,
+    algorithmNode
+  );
+  return rootSizePx;
+}
+var init_smartart_layout_interpreter_hierarchy_fontfit = __esm({
+  "src/core/utils/smartart-layout-interpreter-hierarchy-fontfit.ts"() {
+    init_smartart_layout_item_font_tier();
+  }
+});
 function placeAssistants(hc, x, parentBottom, assistants, options, cursor) {
   for (const assistant of assistants) {
     const y = cursor.y;
@@ -38628,10 +39088,45 @@ function placeHangingForest(hc, roots, startX2, startY, options) {
     placeHangingTree(hc, root, startX2, options, cursor);
   }
 }
+function arrangeFullyHangingTree(nodes, box, palette, style, elementId, roots, itemShape, connectorLabels, algorithmNode, index, fontName, linDir, orgChart) {
+  const { width: w, height: h2 } = box;
+  const boxW = Math.min(w * 0.42, 160);
+  const boxH = Math.min(h2 * 0.16, 30);
+  const indent = boxW * 0.35;
+  const vGap = boxH * 0.55;
+  const hc = baseContext(
+    nodes.length,
+    elementId,
+    palette,
+    style,
+    boxW,
+    boxH,
+    connectorLabels,
+    itemShape,
+    resolveHierarchyItemFontSizePx(nodes, algorithmNode, index, boxW, boxH, fontName)
+  );
+  placeHangingForest(hc, roots, HANGING_MODE_INSET + indent, HANGING_MODE_INSET, {
+    orgChart,
+    direction: linDirHangDirection(linDir),
+    indent,
+    vGap
+  });
+  return {
+    nodes: hc.nodes,
+    connectors: hc.connectors,
+    shadowFilter: hc.ctx.shadow,
+    viewBox: `0 0 ${w} ${h2}`,
+    family: "hierarchy"
+  };
+}
+var HANGING_MODE_INSET;
 var init_smartart_hierarchy_hanging = __esm({
   "src/core/utils/smartart-hierarchy-hanging.ts"() {
+    init_smartart_hierarchy_branch_mode();
     init_smartart_hierarchy_orgchart_tree();
     init_smartart_hierarchy_shared();
+    init_smartart_layout_interpreter_hierarchy_fontfit();
+    HANGING_MODE_INSET = 6;
   }
 });
 function findCompositeDescendant(node) {
@@ -38654,7 +39149,7 @@ function findTextBearingChild(compositeNode) {
     (child262) => (child262.presentationOf?.axis ?? []).includes("self")
   );
 }
-function resolveCompositeChildGeometry(algorithmNode, wrapperAspect) {
+function resolveCompositeChildGeometry(algorithmNode, wrapperAspect, allowOmittedWidthFactor = false) {
   const compositeNode = findCompositeDescendant(algorithmNode);
   if (!compositeNode) {
     return void 0;
@@ -38665,12 +39160,15 @@ function resolveCompositeChildGeometry(algorithmNode, wrapperAspect) {
   }
   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"
+    (c) => c.type === "w" && c.for === "ch" && c.forName === child262.name && c.referenceType === "w" && c.referenceForName === void 0 && (typeof c.factor === "number" || allowOmittedWidthFactor && c.factor === void 0)
   );
-  if (!widthConstr || widthConstr.factor === void 0 || widthConstr.factor <= 0) {
+  if (!widthConstr) {
+    return void 0;
+  }
+  const widthFactor = widthConstr.factor ?? 1;
+  if (widthFactor <= 0) {
     return void 0;
   }
-  const widthFactor = widthConstr.factor;
   const selfHeightConstr = 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"
   );
@@ -38688,11 +39186,15 @@ function resolveCompositeChildGeometry(algorithmNode, wrapperAspect) {
   const parentRelativeHeightConstr = constraints.find(
     (c) => c.type === "h" && c.for === "ch" && c.forName === child262.name && c.referenceType === "h" && c.referenceFor === void 0 && c.referenceForName === void 0 && typeof c.factor === "number"
   );
-  if (parentRelativeHeightConstr && typeof wrapperAspect === "number" && wrapperAspect > 0 && typeof parentRelativeHeightConstr.factor === "number") {
+  const hasCompoundTextRole = constraints.some(
+    (c) => c.type === "primFontSz" && c.referenceForName === child262.name
+  );
+  if (parentRelativeHeightConstr && !hasCompoundTextRole && typeof wrapperAspect === "number" && wrapperAspect > 0 && typeof parentRelativeHeightConstr.factor === "number") {
     return {
       aspectRatio: parentRelativeHeightConstr.factor * wrapperAspect / widthFactor,
       widthFactor,
-      offsetXRatio
+      offsetXRatio,
+      heightFactor: parentRelativeHeightConstr.factor
     };
   }
   return void 0;
@@ -38701,18 +39203,23 @@ var init_smartart_hierarchy_composite_child = __esm({
   "src/core/utils/smartart-hierarchy-composite-child.ts"() {
   }
 });
-function findByReference(constraints, type, referenceType) {
-  const match = (constraints ?? []).find(
-    (c) => c.type === type && c.referenceType === referenceType && typeof c.factor === "number"
-  );
-  return match?.factor;
+function findByReference(constraints, type, referenceType, preferredName) {
+  const list = constraints ?? [];
+  const matches = (c) => c.type === type && c.referenceType === referenceType && typeof c.factor === "number";
+  if (preferredName !== void 0) {
+    const named = list.find((c) => matches(c) && c.forName === preferredName);
+    if (named) {
+      return named.factor;
+    }
+  }
+  return list.find(matches)?.factor;
 }
-function resolveAspectRatio(constraints) {
-  const hRefW = findByReference(constraints, "h", "w");
+function resolveAspectRatio(constraints, preferredName) {
+  const hRefW = findByReference(constraints, "h", "w", preferredName);
   if (hRefW !== void 0 && hRefW > 0) {
     return hRefW;
   }
-  const wRefH = findByReference(constraints, "w", "h");
+  const wRefH = findByReference(constraints, "w", "h", preferredName);
   if (wRefH !== void 0 && wRefH > 0) {
     return 1 / wRefH;
   }
@@ -38877,14 +39384,14 @@ var init_smartart_hierarchy_transpose = __esm({
   "src/core/utils/smartart-hierarchy-transpose.ts"() {
   }
 });
-function fitItemBox(box, columns, levels, sibSpRatio, aspectRatio, generationGapRatio, marginXRatio, marginYRatio, maxHangDepth = 0, clampToNaturalAspect = true, maxHangRows = maxHangDepth, allChildrenHang = false) {
+function fitItemBox(box, columns, levels, sibSpRatio, aspectRatio, generationGapRatio, marginXRatio, marginYRatio, maxHangDepth = 0, clampToNaturalAspect = true, maxHangRows = maxHangDepth, allChildrenHang = false, hangHeightRatio = HANG_HEIGHT_RATIO) {
   const n = Math.max(1, columns);
   const usableW = box.width - 2 * box.width * marginXRatio;
   const allHangExtra = allChildrenHang ? ALL_CHILDREN_HANG_EXTRA_RATIO : 0;
   const widthFit = usableW / (n + Math.max(0, n - 1) * sibSpRatio + maxHangDepth * HIER_TAIL_OFFSET_RATIO + allHangExtra);
   const generations = Math.max(1, levels);
   const usableH = box.height - 2 * box.height * marginYRatio;
-  const heightFit = usableH / (generations + maxHangRows + Math.max(0, generations - 1) * generationGapRatio + maxHangRows * HANG_HEIGHT_RATIO);
+  const heightFit = usableH / (generations + maxHangRows + Math.max(0, generations - 1) * generationGapRatio + maxHangRows * hangHeightRatio);
   const naturalHeight = widthFit * aspectRatio;
   const boxH = clampToNaturalAspect ? Math.min(naturalHeight, heightFit) : heightFit;
   const boxW = clampToNaturalAspect ? boxH / aspectRatio : widthFit;
@@ -38912,7 +39419,7 @@ function resolveHierarchyOrientation(algorithmNode, index, mode = "std", itemSha
     algorithmNode?.rules
   );
   if (sibSpReferencesHeight || tailedTransposed) {
-    const hToW = resolveAspectRatio(constraints);
+    const hToW = resolveAspectRatio(constraints, itemShapeName);
     return {
       transposed: true,
       sibSpRatio,
@@ -38934,8 +39441,12 @@ function resolveHierarchyOrientation(algorithmNode, index, mode = "std", itemSha
       cardOffsetXRatio: 0
     };
   }
-  const compositeAspect = resolveAspectRatio(constraints);
-  const compositeChild = resolveCompositeChildGeometry(algorithmNode, compositeAspect);
+  const compositeAspect = resolveAspectRatio(constraints, itemShapeName);
+  const compositeChild = resolveCompositeChildGeometry(
+    algorithmNode,
+    compositeAspect,
+    mode === "tailed"
+  );
   const aspectRatio = compositeChild?.aspectRatio ?? compositeAspect;
   const tailedMargin = mode === "tailed";
   return {
@@ -38972,6 +39483,7 @@ function resolveHierarchyOrientation(algorithmNode, index, mode = "std", itemSha
     marginXRatio: tailedMargin ? 0 : OUTER_MARGIN_X_RATIO,
     marginYRatio: tailedMargin ? 0 : OUTER_MARGIN_Y_RATIO,
     compositeWidthFactor: compositeChild?.widthFactor,
+    compositeHeightFactor: compositeChild?.heightFactor,
     cardOffsetXRatio: compositeChild?.offsetXRatio ?? 0
   };
 }
@@ -39076,10 +39588,11 @@ function placeFlatChildren(hc, parentId, normal, cx, cy, xOffset, level, cellW,
       offset += childW;
     }
   }
+  const cascadeShift = options.cascadeOffsetX && level + 1 >= options.cascadeOffsetX.fromLevel ? options.cascadeOffsetX.offsetPx : 0;
   let childOffset = xOffset;
   for (const child262 of normal) {
     const childW = spanOf(child262, options);
-    const childCx = (childOffset + childW / 2) * cellW;
+    const childCx = (childOffset + childW / 2) * cellW + cascadeShift;
     const childCy = (level + 1) * cellH + cellH / 2;
     elbowConnector(
       hc,
@@ -39260,7 +39773,7 @@ function placeAt(hc, t, cx, cy, xOffset, spanW, level, cellW, cellH, options, si
       placeFlatChildren2(hc, t.node.id, normal, cx, cy, xOffset, level, cellW, cellH, options);
       return;
     }
-    const anchorY = cy + hc.boxH / 2 + HANG_HEIGHT_RATIO * hc.boxH;
+    const anchorY = cy + hc.boxH / 2 + (options.hangHeightRatio ?? HANG_HEIGHT_RATIO) * hc.boxH;
     const columnOffset = hc.boxW * HIER_TAIL_OFFSET_RATIO;
     for (const child262 of normal) {
       elbowConnector(
@@ -39296,7 +39809,8 @@ function placeAt(hc, t, cx, cy, xOffset, spanW, level, cellW, cellH, options, si
 }
 function placeStandardTree(hc, t, xOffset, level, cellW, cellH, options) {
   const spanW = spanOf(t, options);
-  const cx = (xOffset + spanW / 2) * cellW;
+  const cascadeShift = options.cascadeOffsetX && level >= options.cascadeOffsetX.fromLevel ? options.cascadeOffsetX.offsetPx : 0;
+  const cx = (xOffset + spanW / 2) * cellW + cascadeShift;
   const cy = level * cellH + cellH / 2;
   placeAt(hc, t, cx, cy, xOffset, spanW, level, cellW, cellH, options);
 }
@@ -39310,36 +39824,6 @@ var init_smartart_hierarchy_standard = __esm({
     init_smartart_hierarchy_wrapped_groups();
   }
 });
-function resolveHierarchyItemFontSizePx(nodes, algorithmNode, index, boxW, boxH, fontName) {
-  if (!algorithmNode) {
-    return void 0;
-  }
-  const textNodes = nodes.filter((node) => node.text && node.text.trim().length > 0);
-  if (textNodes.length === 0) {
-    return void 0;
-  }
-  const plan = { node: algorithmNode };
-  const { rootSizePx } = resolveTieredItemFontSize(
-    plan,
-    index,
-    textNodes.map((node) => ({
-      rootText: node.text,
-      descendantTexts: [],
-      width: boxW,
-      height: boxH
-    })),
-    fontName,
-    void 0,
-    0,
-    algorithmNode
-  );
-  return rootSizePx;
-}
-var init_smartart_layout_interpreter_hierarchy_fontfit = __esm({
-  "src/core/utils/smartart-layout-interpreter-hierarchy-fontfit.ts"() {
-    init_smartart_layout_item_font_tier();
-  }
-});
 function arrangeHierarchy(nodes, box, palette, style, elementId, presLayoutVars, connectorLabels, algorithmNode, index = EMPTY_CONSTRAINT_INDEX, childOrder3, fontName) {
   const { width: w, height: h2 } = box;
   const orgChart = presLayoutVars?.orgChart === true;
@@ -39349,28 +39833,21 @@ function arrangeHierarchy(nodes, box, palette, style, elementId, presLayoutVars,
   const mode = branchMode(presLayoutVars, linDir);
   const itemShape = algorithmNode ? findHierarchyItemShape(algorithmNode) : void 0;
   if (mode === "hanging") {
-    const boxW2 = Math.min(w * 0.42, 160);
-    const boxH2 = Math.min(h2 * 0.16, 30);
-    const indent = boxW2 * 0.35;
-    const vGap = boxH2 * 0.55;
-    const hc2 = baseContext(
-      nodes.length,
-      elementId,
+    return arrangeFullyHangingTree(
+      nodes,
+      box,
       palette,
       style,
-      boxW2,
-      boxH2,
-      connectorLabels,
+      elementId,
+      roots,
       itemShape,
-      resolveHierarchyItemFontSizePx(nodes, algorithmNode, index, boxW2, boxH2, fontName)
+      connectorLabels,
+      algorithmNode,
+      index,
+      fontName,
+      linDir,
+      orgChart
     );
-    placeHangingForest(hc2, roots, INSET3 + indent, INSET3, {
-      orgChart,
-      direction: linDirHangDirection(linDir),
-      indent,
-      vGap
-    });
-    return finish(hc2.nodes, hc2.connectors, hc2.ctx.shadow, w, h2);
   }
   const orientation = resolveHierarchyOrientation(
     algorithmNode,
@@ -39398,8 +39875,10 @@ function arrangeHierarchy(nodes, box, palette, style, elementId, presLayoutVars,
     hangShape.maxHangDepth,
     void 0,
     hangShape.maxHangRows,
-    hangShape.allChildrenHang
+    hangShape.allChildrenHang,
+    orientation.transposed ? orientation.generationGapRatio : void 0
   );
+  const cascadePlan = resolveCascadePlan(mode, orientation, depth, hangShape, boxW);
   const tailedPitch = mode === "tailed";
   const { xPitch, yPitch } = computeHierarchyAxisPitches(
     effectiveBox,
@@ -39407,8 +39886,8 @@ function arrangeHierarchy(nodes, box, palette, style, elementId, presLayoutVars,
     boxW,
     boxH,
     totalLeaves,
-    depth,
-    hangShape,
+    cascadePlan.pitchDepth,
+    cascadePlan.pitchHangShape,
     tailedPitch
   );
   const cellW = xPitch.pitch;
@@ -39428,9 +39907,11 @@ function arrangeHierarchy(nodes, box, palette, style, elementId, presLayoutVars,
     orgChart,
     perRow: rowSize,
     foldDeeperGenerations: algorithmNode ? hierarchyLeafFoldsDescendants(algorithmNode) : false,
-    resolveSpan: fanAwareWidthMap ? (t) => resolveSpanWidth(fanAwareWidthMap, t, orgChart) : void 0
+    resolveSpan: fanAwareWidthMap ? (t) => resolveSpanWidth(fanAwareWidthMap, t, orgChart) : void 0,
+    hangHeightRatio: orientation.transposed ? orientation.generationGapRatio : void 0,
+    cascadeOffsetX: cascadePlan.cascadeOffsetX
   };
-  if (mode === "tailed") {
+  if (mode === "tailed" && !cascadePlan.active) {
     const indent = boxW * HIER_TAIL_OFFSET_RATIO;
     const vGap = boxH * 0.55;
     const direction = tailDirection();
@@ -39458,13 +39939,13 @@ function arrangeHierarchy(nodes, box, palette, style, elementId, presLayoutVars,
 function finish(nodes, connectors, shadowFilter, w, h2) {
   return { nodes, connectors, shadowFilter, viewBox: `0 0 ${w} ${h2}`, family: "hierarchy" };
 }
-var INSET3;
 var init_smartart_layout_interpreter_hierarchy = __esm({
   "src/core/utils/smartart-layout-interpreter-hierarchy.ts"() {
     init_smartart_constraint_solver();
     init_smartart_helpers();
     init_smartart_hierarchy_axis_pitch();
     init_smartart_hierarchy_branch_mode();
+    init_smartart_hierarchy_cascade();
     init_smartart_hierarchy_fan_aware_width();
     init_smartart_hierarchy_fold_depth();
     init_smartart_hierarchy_hang_depth();
@@ -39476,7 +39957,6 @@ var init_smartart_layout_interpreter_hierarchy = __esm({
     init_smartart_hierarchy_standard();
     init_smartart_layout_interpreter_hierarchy_fontfit();
     init_smartart_layout_interpreter_model();
-    INSET3 = 6;
   }
 });
 function isChildNodeForEach(entry2) {
@@ -40209,7 +40689,7 @@ function repositionPyramidBands(result, box, planNode, topLevelIds, flatNodes, h
     index,
     roleOf(planNode),
     ["sibSp", "sp"],
-    DEFAULT_GAP_RATIO
+    DEFAULT_GAP_RATIO2
   );
   const inverted = algorithmParam(planNode, "linDir") === "fromT";
   const nodes = result.nodes.map((rendered) => {
@@ -40334,7 +40814,8 @@ function runArrangement(input) {
     resolveNamedRuleOverride(collectNamedRules(layoutDefinition), itemNode(plan.node)?.name),
     box
   ) : result;
-  const withItemRoles = STRUCTURAL_ARRANGEMENT_KINDS.has(plan.kind) ? expandResultItemRoles(
+  const isTableTemplate = isRecursiveTableItemTemplate(plan.node, presLayoutVars);
+  const withItemRoles = STRUCTURAL_ARRANGEMENT_KINDS.has(plan.kind) && !isTableTemplate ? expandResultItemRoles(
     plan.node,
     withNamedRule,
     nodes,
@@ -40395,6 +40876,7 @@ var init_smartart_layout_interpreter = __esm({
     init_smartart_layout_interpreter_hierarchy();
     init_smartart_layout_interpreter_hub();
     init_smartart_layout_interpreter_item_roles();
+    init_smartart_layout_interpreter_linear_table();
     init_smartart_layout_interpreter_model();
     init_smartart_layout_interpreter_named_rules();
     init_smartart_layout_interpreter_pyramid_bands();
@@ -45482,8 +45964,8 @@ function parseDataLabelFieldTable(group2, xmlLookup) {
     return void 0;
   }
   const points4 = [];
-  for (const table of tables) {
-    collectByLocalName2(table, "pt", points4);
+  for (const table2 of tables) {
+    collectByLocalName2(table2, "pt", points4);
   }
   const map = /* @__PURE__ */ new Map();
   for (const pt2 of points4) {
@@ -56158,16 +56640,327 @@ var init_slide_title = __esm({
     TITLE_PLACEHOLDER_TYPES = /* @__PURE__ */ new Set(["title", "ctrtitle"]);
   }
 });
+function readMaskChannel(value, mask) {
+  if (mask === 0) {
+    return 0;
+  }
+  let m = mask;
+  let shift = 0;
+  while ((m & 1) === 0) {
+    m >>>= 1;
+    shift++;
+  }
+  const bits = 32 - Math.clz32(m);
+  const raw = (value & mask) >>> shift;
+  const maxVal = (1 << bits) - 1;
+  return maxVal === 0 ? 0 : Math.round(raw / maxVal * 255);
+}
+function decodeBmpFirstPixel(bytes) {
+  if (bytes.length < 54 || bytes[0] !== 66 || bytes[1] !== 77) {
+    return void 0;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const pixelDataOffset = view.getUint32(10, true);
+  const headerSize = view.getUint32(14, true);
+  if (headerSize < 40) {
+    return void 0;
+  }
+  const width = view.getInt32(18, true);
+  const rawHeight = view.getInt32(22, true);
+  const bitCount = view.getUint16(28, true);
+  const compression = view.getUint32(30, true);
+  if (width <= 0 || rawHeight === 0) {
+    return void 0;
+  }
+  const topDown = rawHeight < 0;
+  const height = Math.abs(rawHeight);
+  let redMask = 16711680;
+  let greenMask = 65280;
+  let blueMask = 255;
+  let paletteOffset = 14 + headerSize;
+  if (compression === 3) {
+    redMask = view.getUint32(54, true);
+    greenMask = view.getUint32(58, true);
+    blueMask = view.getUint32(62, true);
+    paletteOffset = 54 + 12;
+  } else if (compression !== 0) {
+    return void 0;
+  }
+  const rowStride = Math.ceil(width * bitCount / 32) * 4;
+  const rowIndexFromTop = 0;
+  const storedRowIndex = topDown ? rowIndexFromTop : height - 1 - rowIndexFromTop;
+  const rowStart = pixelDataOffset + storedRowIndex * rowStride;
+  if (rowStart < 0 || rowStart + Math.ceil(bitCount / 8) > bytes.length) {
+    return void 0;
+  }
+  if (bitCount <= 8) {
+    const paletteCount = 1 << bitCount;
+    if (paletteOffset + paletteCount * 4 > bytes.length) {
+      return void 0;
+    }
+    let index;
+    if (bitCount === 8) {
+      index = bytes[rowStart];
+    } else {
+      const byte = bytes[rowStart];
+      index = byte >> 8 - bitCount;
+    }
+    const entry2 = paletteOffset + index * 4;
+    return { r: bytes[entry2 + 2], g: bytes[entry2 + 1], b: bytes[entry2], a: 255 };
+  }
+  if (bitCount === 24) {
+    return { r: bytes[rowStart + 2], g: bytes[rowStart + 1], b: bytes[rowStart], a: 255 };
+  }
+  if (bitCount === 32) {
+    const value = bytes[rowStart] | bytes[rowStart + 1] << 8 | bytes[rowStart + 2] << 16 | bytes[rowStart + 3] << 24;
+    return {
+      r: readMaskChannel(value, redMask),
+      g: readMaskChannel(value, greenMask),
+      b: readMaskChannel(value, blueMask),
+      a: 255
+    };
+  }
+  if (bitCount === 16) {
+    const value = bytes[rowStart] | bytes[rowStart + 1] << 8;
+    if (compression === 3) {
+      return {
+        r: readMaskChannel(value, redMask),
+        g: readMaskChannel(value, greenMask),
+        b: readMaskChannel(value, blueMask),
+        a: 255
+      };
+    }
+    const r5 = value >> 10 & 31;
+    const g5 = value >> 5 & 31;
+    const b5 = value & 31;
+    const scale2 = (v) => Math.round(v / 31 * 255);
+    return { r: scale2(r5), g: scale2(g5), b: scale2(b5), a: 255 };
+  }
+  return void 0;
+}
 var init_image_first_pixel_bmp = __esm({
   "src/core/utils/image-first-pixel-bmp.ts"() {
   }
 });
+function readFirstColorIndex(data, subBlocksStart, minCodeSize) {
+  const clearCode = 1 << minCodeSize;
+  const endCode = clearCode + 1;
+  let codeSize = minCodeSize + 1;
+  const reader = new GifSubBlockBitReader(data, subBlocksStart);
+  for (let guard = 0; guard < 8; guard++) {
+    const code = reader.bits(codeSize);
+    if (code === void 0 || code === endCode) {
+      return void 0;
+    }
+    if (code === clearCode) {
+      codeSize = minCodeSize + 1;
+      continue;
+    }
+    return code < clearCode ? code : void 0;
+  }
+  return void 0;
+}
+function locateFirstImage(data, start) {
+  let pos2 = start;
+  let transparentIndex;
+  while (pos2 < data.length) {
+    const marker = data[pos2];
+    if (marker === 33) {
+      const label = data[pos2 + 1];
+      pos2 += 2;
+      if (label === 249 && data[pos2] === 4) {
+        const packed = data[pos2 + 1];
+        const hasTransparency = (packed & 1) !== 0;
+        if (hasTransparency) {
+          transparentIndex = data[pos2 + 4];
+        }
+      }
+      for (; ; ) {
+        const len = data[pos2];
+        pos2 += 1 + len;
+        if (len === 0 || pos2 >= data.length) {
+          break;
+        }
+      }
+    } else if (marker === 44) {
+      const packed = data[pos2 + 9];
+      let cursor = pos2 + 10;
+      let localColorTable;
+      if (packed & 128) {
+        const size = 2 << (packed & 7);
+        localColorTable = data.subarray(cursor, cursor + size * 3);
+        cursor += size * 3;
+      }
+      const minCodeSize = data[cursor];
+      cursor += 1;
+      return { image: { subBlocksStart: cursor, minCodeSize, localColorTable }, transparentIndex };
+    } else {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function decodeGifFirstPixel(bytes) {
+  if (bytes.length < 13) {
+    return void 0;
+  }
+  const sig = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]);
+  if (sig !== "GIF87a" && sig !== "GIF89a") {
+    return void 0;
+  }
+  const packed = bytes[10];
+  let pos2 = 13;
+  let globalColorTable;
+  if (packed & 128) {
+    const size = 2 << (packed & 7);
+    globalColorTable = bytes.subarray(pos2, pos2 + size * 3);
+    pos2 += size * 3;
+  }
+  const located = locateFirstImage(bytes, pos2);
+  if (!located) {
+    return void 0;
+  }
+  const { image, transparentIndex } = located;
+  const index = readFirstColorIndex(bytes, image.subBlocksStart, image.minCodeSize);
+  if (index === void 0) {
+    return void 0;
+  }
+  const table2 = image.localColorTable ?? globalColorTable;
+  if (!table2 || table2.length < (index + 1) * 3) {
+    return void 0;
+  }
+  if (transparentIndex === index) {
+    return void 0;
+  }
+  return { r: table2[index * 3], g: table2[index * 3 + 1], b: table2[index * 3 + 2], a: 255 };
+}
+var GifSubBlockBitReader;
 var init_image_first_pixel_gif = __esm({
   "src/core/utils/image-first-pixel-gif.ts"() {
+    GifSubBlockBitReader = class {
+      constructor(data, pos2) {
+        this.data = data;
+        this.pos = pos2;
+      }
+      data;
+      pos;
+      blockBytes = new Uint8Array(0);
+      blockPos = 0;
+      bitBuf = 0;
+      bitCount = 0;
+      ended = false;
+      nextByte() {
+        if (this.blockPos >= this.blockBytes.length) {
+          if (this.ended || this.pos >= this.data.length) {
+            this.ended = true;
+            return void 0;
+          }
+          const len = this.data[this.pos];
+          this.pos += 1;
+          if (len === 0) {
+            this.ended = true;
+            return void 0;
+          }
+          this.blockBytes = this.data.subarray(this.pos, this.pos + len);
+          this.blockPos = 0;
+          this.pos += len;
+        }
+        return this.blockBytes[this.blockPos++];
+      }
+      /** Read `count` bits, LSB-first. Returns `undefined` at end of data. */
+      bits(count) {
+        while (this.bitCount < count) {
+          const byte = this.nextByte();
+          if (byte === void 0) {
+            return void 0;
+          }
+          this.bitBuf |= byte << this.bitCount;
+          this.bitCount += 8;
+        }
+        const value = this.bitBuf & (1 << count) - 1;
+        this.bitBuf >>>= count;
+        this.bitCount -= count;
+        return value;
+      }
+    };
   }
 });
+function buildJpegHuffmanTable(bits, huffval) {
+  const counts = new Uint16Array(17);
+  for (let len = 1; len <= 16; len++) {
+    counts[len] = bits[len - 1];
+  }
+  return { counts, symbols: huffval };
+}
+function decodeJpegHuffmanSymbol(reader, table2) {
+  let code = 0;
+  let first = 0;
+  let index = 0;
+  for (let len = 1; len <= 16; len++) {
+    code = code << 1 | reader.bits(1);
+    const count = table2.counts[len];
+    if (count > 0 && code - first < count) {
+      return table2.symbols[index + (code - first)];
+    }
+    index += count;
+    first += count;
+    first <<= 1;
+  }
+  throw new Error("jpeg: invalid Huffman code");
+}
+function extendSigned(value, size) {
+  if (size === 0) {
+    return 0;
+  }
+  const half = 1 << size - 1;
+  return value < half ? value - (1 << size) + 1 : value;
+}
+var JpegBitReader;
 var init_image_first_pixel_jpeg_bitstream = __esm({
   "src/core/utils/image-first-pixel-jpeg-bitstream.ts"() {
+    JpegBitReader = class {
+      constructor(data, startOffset) {
+        this.data = data;
+        this.pos = startOffset;
+      }
+      data;
+      pos;
+      currentByte = 0;
+      bitsLeftInByte = 0;
+      /** Set once a raw (non-stuffed) 0xFF marker byte is encountered: end of this scan's data. */
+      hitMarker = false;
+      nextBit() {
+        if (this.bitsLeftInByte === 0) {
+          if (this.hitMarker || this.pos >= this.data.length) {
+            return 0;
+          }
+          const byte = this.data[this.pos];
+          if (byte === 255) {
+            const next = this.data[this.pos + 1];
+            if (next === 0) {
+              this.pos += 2;
+            } else {
+              this.hitMarker = true;
+              return 0;
+            }
+          } else {
+            this.pos += 1;
+          }
+          this.currentByte = byte;
+          this.bitsLeftInByte = 8;
+        }
+        this.bitsLeftInByte -= 1;
+        return this.currentByte >> this.bitsLeftInByte & 1;
+      }
+      /** Read `count` (0-16) bits MSB-first as an unsigned integer. */
+      bits(count) {
+        let value = 0;
+        for (let i2 = 0; i2 < count; i2++) {
+          value = value << 1 | this.nextBit();
+        }
+        return value >>> 0;
+      }
+    };
   }
 });
 function cornerIdctWeight(u, v) {
@@ -56175,10 +56968,238 @@ function cornerIdctWeight(u, v) {
   const cv = v === 0 ? 1 / Math.SQRT2 : 1;
   return 0.25 * cu * cv * Math.cos(u * Math.PI / 16) * Math.cos(v * Math.PI / 16);
 }
+function decodeBlockCornerSample(reader, dcTable, acTable, quantTable) {
+  const coeffs = new Float64Array(64);
+  const dcSize = decodeJpegHuffmanSymbol(reader, dcTable);
+  const dcBits = reader.bits(dcSize);
+  const dc = extendSigned(dcBits, dcSize);
+  coeffs[0] = dc * quantTable[0];
+  let k = 1;
+  while (k < 64) {
+    const rs = decodeJpegHuffmanSymbol(reader, acTable);
+    const run = rs >> 4;
+    const size = rs & 15;
+    if (size === 0) {
+      if (run === 15) {
+        k += 16;
+        continue;
+      }
+      break;
+    }
+    k += run;
+    if (k >= 64) {
+      break;
+    }
+    const bits = reader.bits(size);
+    const value = extendSigned(bits, size);
+    const naturalIndex = ZIGZAG[k];
+    coeffs[naturalIndex] = value * quantTable[k];
+    k += 1;
+  }
+  let sum = 0;
+  for (let i2 = 0; i2 < 64; i2++) {
+    sum += coeffs[i2] * CORNER_WEIGHTS[i2];
+  }
+  return sum;
+}
+function clamp8(value) {
+  return Math.max(0, Math.min(255, Math.round(value)));
+}
+function decodeJpegFirstPixel(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) {
+    return void 0;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const quantTables = /* @__PURE__ */ new Map();
+  const dcTables = /* @__PURE__ */ new Map();
+  const acTables = /* @__PURE__ */ new Map();
+  let components;
+  let pos2 = 2;
+  try {
+    while (pos2 + 4 <= bytes.length) {
+      if (bytes[pos2] !== 255) {
+        pos2 += 1;
+        continue;
+      }
+      const marker = bytes[pos2 + 1];
+      if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+        pos2 += 2;
+        continue;
+      }
+      if (marker === 217) {
+        return void 0;
+      }
+      const length = view.getUint16(pos2 + 2, false);
+      const segStart = pos2 + 4;
+      if (marker === 219) {
+        let off = segStart;
+        const segEnd = pos2 + 2 + length;
+        while (off < segEnd) {
+          const pq = bytes[off] >> 4;
+          const tq = bytes[off] & 15;
+          off += 1;
+          const table2 = new Uint16Array(64);
+          for (let i2 = 0; i2 < 64; i2++) {
+            table2[i2] = pq === 0 ? bytes[off + i2] : view.getUint16(off + i2 * 2, false);
+          }
+          off += pq === 0 ? 64 : 128;
+          quantTables.set(tq, table2);
+        }
+      } else if (marker === 192 || marker === 193) {
+        const numComponents = bytes[segStart + 5];
+        components = [];
+        for (let i2 = 0; i2 < numComponents; i2++) {
+          const base = segStart + 6 + i2 * 3;
+          components.push({
+            id: bytes[base],
+            hSampling: bytes[base + 1] >> 4,
+            vSampling: bytes[base + 1] & 15,
+            quantTableId: bytes[base + 2]
+          });
+        }
+      } else if (marker === 194) {
+        return void 0;
+      } else if (marker === 196) {
+        let off = segStart;
+        const segEnd = pos2 + 2 + length;
+        while (off < segEnd) {
+          const tc = bytes[off] >> 4;
+          const th = bytes[off] & 15;
+          off += 1;
+          const bits = bytes.subarray(off, off + 16);
+          off += 16;
+          const total = bits.reduce((s, b) => s + b, 0);
+          const huffval = bytes.subarray(off, off + total);
+          off += total;
+          const table2 = buildJpegHuffmanTable(bits, huffval);
+          (tc === 0 ? dcTables : acTables).set(th, table2);
+        }
+      } else if (marker === 218) {
+        if (!components) {
+          return void 0;
+        }
+        const scanCount = bytes[segStart];
+        const scanComponents = [];
+        for (let i2 = 0; i2 < scanCount; i2++) {
+          const base = segStart + 1 + i2 * 2;
+          const compId = bytes[base];
+          const comp = components.find((c) => c.id === compId);
+          if (!comp) {
+            return void 0;
+          }
+          scanComponents.push({ comp, dcId: bytes[base + 1] >> 4, acId: bytes[base + 1] & 15 });
+        }
+        const reader = new JpegBitReader(bytes, segStart + 1 + scanCount * 2 + 3);
+        const cornerSamples = [];
+        for (const sc of scanComponents) {
+          const dcTable = dcTables.get(sc.dcId);
+          const acTable = acTables.get(sc.acId);
+          const quantTable = quantTables.get(sc.comp.quantTableId);
+          if (!dcTable || !acTable || !quantTable) {
+            return void 0;
+          }
+          const blockCount = sc.comp.hSampling * sc.comp.vSampling;
+          let first;
+          for (let b = 0; b < blockCount; b++) {
+            const sample = decodeBlockCornerSample(reader, dcTable, acTable, quantTable);
+            if (b === 0) {
+              first = sample;
+            }
+          }
+          cornerSamples.push(clamp8(first + 128));
+        }
+        return combineComponentsToRgb(cornerSamples);
+      }
+      pos2 += 2 + length;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function combineComponentsToRgb(samples) {
+  if (samples.length === 1) {
+    const y2 = samples[0];
+    return { r: y2, g: y2, b: y2, a: 255 };
+  }
+  const [y, cb, cr] = samples;
+  const r = clamp8(y + 1.402 * (cr - 128));
+  const g2 = clamp8(y - 0.344136 * (cb - 128) - 0.714136 * (cr - 128));
+  const b = clamp8(y + 1.772 * (cb - 128));
+  return { r, g: g2, b, a: 255 };
+}
+var ZIGZAG;
+var CORNER_WEIGHTS;
 var init_image_first_pixel_jpeg = __esm({
   "src/core/utils/image-first-pixel-jpeg.ts"() {
     init_image_first_pixel_jpeg_bitstream();
-    (() => {
+    ZIGZAG = [
+      0,
+      1,
+      8,
+      16,
+      9,
+      2,
+      3,
+      10,
+      17,
+      24,
+      32,
+      25,
+      18,
+      11,
+      4,
+      5,
+      12,
+      19,
+      26,
+      33,
+      40,
+      48,
+      41,
+      34,
+      27,
+      20,
+      13,
+      6,
+      7,
+      14,
+      21,
+      28,
+      35,
+      42,
+      49,
+      56,
+      57,
+      50,
+      43,
+      36,
+      29,
+      22,
+      15,
+      23,
+      30,
+      37,
+      44,
+      51,
+      58,
+      59,
+      52,
+      45,
+      38,
+      31,
+      39,
+      46,
+      53,
+      60,
+      61,
+      54,
+      47,
+      55,
+      62,
+      63
+    ];
+    CORNER_WEIGHTS = (() => {
       const weights = [];
       for (let naturalIndex = 0; naturalIndex < 64; naturalIndex++) {
         const row = Math.floor(naturalIndex / 8);
@@ -56189,9 +57210,327 @@ var init_image_first_pixel_jpeg = __esm({
     })();
   }
 });
+function buildHuffmanTable(lengths) {
+  const maxBits = Math.max(0, ...lengths);
+  const counts = new Uint16Array(maxBits + 1);
+  for (const len of lengths) {
+    if (len > 0) {
+      counts[len]++;
+    }
+  }
+  const offsets = new Uint16Array(maxBits + 2);
+  for (let bits = 1; bits <= maxBits; bits++) {
+    offsets[bits + 1] = offsets[bits] + counts[bits];
+  }
+  const symbols = new Uint16Array(lengths.filter((l) => l > 0).length);
+  for (let symbol = 0; symbol < lengths.length; symbol++) {
+    const len = lengths[symbol];
+    if (len > 0) {
+      symbols[offsets[len]] = symbol;
+      offsets[len]++;
+    }
+  }
+  return { counts, symbols };
+}
+function decodeSymbol(reader, table2) {
+  let code = 0;
+  let first = 0;
+  let index = 0;
+  for (let len = 1; len < table2.counts.length; len++) {
+    code |= reader.bits(1);
+    const count = table2.counts[len];
+    if (code - first < count) {
+      return table2.symbols[index + (code - first)];
+    }
+    index += count;
+    first += count;
+    first <<= 1;
+    code <<= 1;
+  }
+  throw new Error("inflate: invalid Huffman code");
+}
+function inflateBlock(reader, out, litTable, distTable) {
+  for (; ; ) {
+    if (out.full) {
+      return;
+    }
+    const symbol = decodeSymbol(reader, litTable);
+    if (symbol === 256) {
+      return;
+    }
+    if (symbol < 256) {
+      out.push(symbol);
+      continue;
+    }
+    const lengthIndex = symbol - 257;
+    if (lengthIndex >= LENGTH_BASE.length) {
+      throw new Error("inflate: invalid length symbol");
+    }
+    const length = LENGTH_BASE[lengthIndex] + reader.bits(LENGTH_EXTRA_BITS[lengthIndex]);
+    const distSymbol = decodeSymbol(reader, distTable);
+    if (distSymbol >= DIST_BASE.length) {
+      throw new Error("inflate: invalid distance symbol");
+    }
+    const distance2 = DIST_BASE[distSymbol] + reader.bits(DIST_EXTRA_BITS[distSymbol]);
+    for (let i2 = 0; i2 < length; i2++) {
+      if (out.full) {
+        return;
+      }
+      out.push(out.at(distance2));
+    }
+  }
+}
+function readDynamicTables(reader) {
+  const hlit = reader.bits(5) + 257;
+  const hdist = reader.bits(5) + 1;
+  const hclen = reader.bits(4) + 4;
+  const codeLengthLengths = new Array(19).fill(0);
+  for (let i2 = 0; i2 < hclen; i2++) {
+    codeLengthLengths[CODE_LENGTH_ORDER[i2]] = reader.bits(3);
+  }
+  const codeLengthTable = buildHuffmanTable(codeLengthLengths);
+  const allLengths = [];
+  while (allLengths.length < hlit + hdist) {
+    const symbol = decodeSymbol(reader, codeLengthTable);
+    if (symbol < 16) {
+      allLengths.push(symbol);
+    } else if (symbol === 16) {
+      const prev = allLengths[allLengths.length - 1] ?? 0;
+      const repeat = reader.bits(2) + 3;
+      for (let i2 = 0; i2 < repeat; i2++) {
+        allLengths.push(prev);
+      }
+    } else if (symbol === 17) {
+      const repeat = reader.bits(3) + 3;
+      for (let i2 = 0; i2 < repeat; i2++) {
+        allLengths.push(0);
+      }
+    } else {
+      const repeat = reader.bits(7) + 11;
+      for (let i2 = 0; i2 < repeat; i2++) {
+        allLengths.push(0);
+      }
+    }
+  }
+  const litLengths = allLengths.slice(0, hlit);
+  const distLengths = allLengths.slice(hlit, hlit + hdist);
+  return { lit: buildHuffmanTable(litLengths), dist: buildHuffmanTable(distLengths) };
+}
+function inflateRaw(data, maxOutputBytes = Infinity) {
+  const reader = new BitReader(data);
+  const out = new OutputSink(maxOutputBytes === Infinity ? 1 << 20 : maxOutputBytes);
+  let final = 0;
+  do {
+    final = reader.bits(1);
+    const type = reader.bits(2);
+    if (out.full) {
+      break;
+    }
+    if (type === 0) {
+      reader.alignToByte();
+      const len = reader.readByte() | reader.readByte() << 8;
+      reader.readByte();
+      reader.readByte();
+      for (let i2 = 0; i2 < len; i2++) {
+        if (out.full) {
+          break;
+        }
+        out.push(reader.readByte());
+      }
+    } else if (type === 1) {
+      const lit = buildHuffmanTable(FIXED_LITERAL_LENGTHS);
+      const dist2 = buildHuffmanTable(FIXED_DIST_LENGTHS);
+      inflateBlock(reader, out, lit, dist2);
+    } else if (type === 2) {
+      const { lit, dist: dist2 } = readDynamicTables(reader);
+      inflateBlock(reader, out, lit, dist2);
+    } else {
+      throw new Error("inflate: invalid block type");
+    }
+  } while (!final && !out.full);
+  return out.toBytes();
+}
+function zlibInflate(data, maxOutputBytes = Infinity) {
+  if (data.length < 2) {
+    throw new Error("inflate: truncated zlib stream");
+  }
+  return inflateRaw(data.subarray(2), maxOutputBytes);
+}
+var LENGTH_BASE;
+var LENGTH_EXTRA_BITS;
+var DIST_BASE;
+var DIST_EXTRA_BITS;
+var CODE_LENGTH_ORDER;
+var BitReader;
+var FIXED_LITERAL_LENGTHS;
+var FIXED_DIST_LENGTHS;
+var OutputSink;
 var init_inflate = __esm({
   "src/core/utils/inflate.ts"() {
-    (() => {
+    LENGTH_BASE = [
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      13,
+      15,
+      17,
+      19,
+      23,
+      27,
+      31,
+      35,
+      43,
+      51,
+      59,
+      67,
+      83,
+      99,
+      115,
+      131,
+      163,
+      195,
+      227,
+      258
+    ];
+    LENGTH_EXTRA_BITS = [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      2,
+      2,
+      2,
+      2,
+      3,
+      3,
+      3,
+      3,
+      4,
+      4,
+      4,
+      4,
+      5,
+      5,
+      5,
+      5,
+      0
+    ];
+    DIST_BASE = [
+      1,
+      2,
+      3,
+      4,
+      5,
+      7,
+      9,
+      13,
+      17,
+      25,
+      33,
+      49,
+      65,
+      97,
+      129,
+      193,
+      257,
+      385,
+      513,
+      769,
+      1025,
+      1537,
+      2049,
+      3073,
+      4097,
+      6145,
+      8193,
+      12289,
+      16385,
+      24577
+    ];
+    DIST_EXTRA_BITS = [
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      2,
+      2,
+      3,
+      3,
+      4,
+      4,
+      5,
+      5,
+      6,
+      6,
+      7,
+      7,
+      8,
+      8,
+      9,
+      9,
+      10,
+      10,
+      11,
+      11,
+      12,
+      12,
+      13,
+      13
+    ];
+    CODE_LENGTH_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+    BitReader = class {
+      constructor(data) {
+        this.data = data;
+      }
+      data;
+      pos = 0;
+      bitBuf = 0;
+      bitCount = 0;
+      get bytePos() {
+        return this.pos;
+      }
+      bits(count) {
+        while (this.bitCount < count) {
+          if (this.pos >= this.data.length) {
+            throw new Error("inflate: unexpected end of stream");
+          }
+          this.bitBuf |= this.data[this.pos] << this.bitCount;
+          this.pos++;
+          this.bitCount += 8;
+        }
+        const value = this.bitBuf & (1 << count) - 1;
+        this.bitBuf >>>= count;
+        this.bitCount -= count;
+        return value;
+      }
+      alignToByte() {
+        this.bitBuf = 0;
+        this.bitCount = 0;
+      }
+      readByte() {
+        if (this.pos >= this.data.length) {
+          throw new Error("inflate: unexpected end of stream");
+        }
+        return this.data[this.pos++];
+      }
+    };
+    FIXED_LITERAL_LENGTHS = (() => {
       const lengths = new Array(288);
       for (let i2 = 0; i2 < 144; i2++) {
         lengths[i2] = 8;
@@ -56207,14 +57546,251 @@ var init_inflate = __esm({
       }
       return lengths;
     })();
-    new Array(30).fill(5);
+    FIXED_DIST_LENGTHS = new Array(30).fill(5);
+    OutputSink = class {
+      constructor(limit) {
+        this.limit = limit;
+        this.buf = new Uint8Array(Math.min(limit, 4096) || 64);
+      }
+      limit;
+      buf;
+      len = 0;
+      get length() {
+        return this.len;
+      }
+      get full() {
+        return this.len >= this.limit;
+      }
+      push(byte) {
+        if (this.len >= this.buf.length) {
+          const next = new Uint8Array(Math.min(this.limit, this.buf.length * 2));
+          next.set(this.buf);
+          this.buf = next;
+        }
+        this.buf[this.len++] = byte;
+      }
+      at(offsetFromEnd) {
+        return this.buf[this.len - offsetFromEnd];
+      }
+      toBytes() {
+        return this.buf.subarray(0, this.len);
+      }
+    };
   }
 });
+function channelsForColorType(colorType) {
+  switch (colorType) {
+    case 0:
+      return 1;
+    // grayscale
+    case 2:
+      return 3;
+    // truecolor
+    case 3:
+      return 1;
+    // indexed
+    case 4:
+      return 2;
+    // grayscale + alpha
+    case 6:
+      return 4;
+    // truecolor + alpha
+    default:
+      return void 0;
+  }
+}
+function hasPngSignature(bytes) {
+  if (bytes.length < 8) {
+    return false;
+  }
+  for (let i2 = 0; i2 < PNG_SIGNATURE2.length; i2++) {
+    if (bytes[i2] !== PNG_SIGNATURE2[i2]) {
+      return false;
+    }
+  }
+  return true;
+}
+function readChunks(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 8;
+  let header;
+  let palette;
+  let transparency;
+  const idatParts = [];
+  let idatTotal = 0;
+  while (offset + 8 <= bytes.length) {
+    const length = view.getUint32(offset, false);
+    const type = String.fromCharCode(
+      bytes[offset + 4],
+      bytes[offset + 5],
+      bytes[offset + 6],
+      bytes[offset + 7]
+    );
+    const dataStart = offset + 8;
+    if (dataStart + length > bytes.length) {
+      break;
+    }
+    const data = bytes.subarray(dataStart, dataStart + length);
+    if (type === "IHDR" && length >= 13) {
+      header = {
+        width: view.getUint32(dataStart, false),
+        height: view.getUint32(dataStart + 4, false),
+        bitDepth: data[8],
+        colorType: data[9]
+      };
+    } else if (type === "PLTE") {
+      palette = data;
+    } else if (type === "tRNS") {
+      transparency = data;
+    } else if (type === "IDAT") {
+      idatParts.push(data);
+      idatTotal += data.length;
+      if (idatTotal > 4096) {
+        break;
+      }
+    } else if (type === "IEND") {
+      break;
+    }
+    offset = dataStart + length + 4;
+  }
+  const idat = new Uint8Array(idatTotal);
+  let pos2 = 0;
+  for (const part of idatParts) {
+    idat.set(part, pos2);
+    pos2 += part.length;
+  }
+  return { header, palette, transparency, idat };
+}
+function firstSample(byte, bitDepth) {
+  if (bitDepth >= 8) {
+    return byte;
+  }
+  return byte >> 8 - bitDepth;
+}
+function scaleTo8Bit(value, bitDepth) {
+  if (bitDepth === 8) {
+    return value;
+  }
+  if (bitDepth === 16) {
+    return value;
+  }
+  const maxVal = (1 << bitDepth) - 1;
+  return Math.round(value / maxVal * 255);
+}
+function decodePngFirstPixel(bytes) {
+  if (!hasPngSignature(bytes)) {
+    return void 0;
+  }
+  const { header, palette, transparency, idat } = readChunks(bytes);
+  if (!header || idat.length === 0) {
+    return void 0;
+  }
+  const channels = channelsForColorType(header.colorType);
+  if (channels === void 0) {
+    return void 0;
+  }
+  const bytesPerSample = header.bitDepth === 16 ? 2 : 1;
+  const neededDataBytes = header.bitDepth < 8 ? 1 : channels * bytesPerSample;
+  let raw;
+  try {
+    raw = zlibInflate(idat, 1 + neededDataBytes);
+  } catch {
+    return void 0;
+  }
+  if (raw.length < 1 + neededDataBytes) {
+    return void 0;
+  }
+  const data = raw.subarray(1);
+  const readSample = (index) => {
+    if (header.bitDepth < 8) {
+      return firstSample(data[0], header.bitDepth);
+    }
+    if (header.bitDepth === 16) {
+      return data[index * 2];
+    }
+    return data[index];
+  };
+  switch (header.colorType) {
+    case 0: {
+      const gray = scaleTo8Bit(readSample(0), header.bitDepth);
+      const isTransparent = transparency && transparency.length >= 2 && readSample(0) === (transparency[1] ?? -1);
+      return { r: gray, g: gray, b: gray, a: isTransparent ? 0 : 255 };
+    }
+    case 2: {
+      const r = scaleTo8Bit(readSample(0), header.bitDepth);
+      const g2 = scaleTo8Bit(readSample(1), header.bitDepth);
+      const b = scaleTo8Bit(readSample(2), header.bitDepth);
+      return { r, g: g2, b, a: 255 };
+    }
+    case 3: {
+      const index = readSample(0);
+      if (!palette || palette.length < (index + 1) * 3) {
+        return void 0;
+      }
+      const alpha = transparency && transparency.length > index ? transparency[index] : 255;
+      return {
+        r: palette[index * 3],
+        g: palette[index * 3 + 1],
+        b: palette[index * 3 + 2],
+        a: alpha
+      };
+    }
+    case 4: {
+      const gray = scaleTo8Bit(readSample(0), header.bitDepth);
+      const alpha = scaleTo8Bit(readSample(1), header.bitDepth);
+      return { r: gray, g: gray, b: gray, a: alpha };
+    }
+    case 6: {
+      const r = scaleTo8Bit(readSample(0), header.bitDepth);
+      const g2 = scaleTo8Bit(readSample(1), header.bitDepth);
+      const b = scaleTo8Bit(readSample(2), header.bitDepth);
+      const a = scaleTo8Bit(readSample(3), header.bitDepth);
+      return { r, g: g2, b, a };
+    }
+    default:
+      return void 0;
+  }
+}
+var PNG_SIGNATURE2;
 var init_image_first_pixel_png = __esm({
   "src/core/utils/image-first-pixel-png.ts"() {
     init_inflate();
+    PNG_SIGNATURE2 = [137, 80, 78, 71, 13, 10, 26, 10];
   }
 });
+function hexChannel(value) {
+  return Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0");
+}
+function sniffAndDecode(bytes) {
+  if (bytes.length < 4) {
+    return void 0;
+  }
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return decodePngFirstPixel(bytes);
+  }
+  if (bytes[0] === 255 && bytes[1] === 216) {
+    return decodeJpegFirstPixel(bytes);
+  }
+  if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) {
+    return decodeGifFirstPixel(bytes);
+  }
+  if (bytes[0] === 66 && bytes[1] === 77) {
+    return decodeBmpFirstPixel(bytes);
+  }
+  return void 0;
+}
+function sampleFirstPixelColorFromBytes(bytes) {
+  let pixel;
+  try {
+    pixel = sniffAndDecode(bytes);
+  } catch {
+    return void 0;
+  }
+  if (!pixel || pixel.a === 0) {
+    return void 0;
+  }
+  return `#${hexChannel(pixel.r)}${hexChannel(pixel.g)}${hexChannel(pixel.b)}`;
+}
 var init_image_first_pixel = __esm({
   "src/core/utils/image-first-pixel.ts"() {
     init_image_first_pixel_bmp();
@@ -56223,30 +57799,532 @@ var init_image_first_pixel = __esm({
     init_image_first_pixel_png();
   }
 });
+function readFrameAt(bytes, offset) {
+  if (offset + 7 > bytes.length) {
+    return void 0;
+  }
+  if (bytes[offset] !== 255 || (bytes[offset + 1] & 240) !== 240) {
+    return void 0;
+  }
+  const freqIndex = bytes[offset + 2] >> 2 & 15;
+  const sampleRate = SAMPLE_RATES[freqIndex];
+  if (!sampleRate) {
+    return void 0;
+  }
+  const length = (bytes[offset + 3] & 3) << 11 | bytes[offset + 4] << 3 | bytes[offset + 5] >> 5 & 7;
+  if (length < 7) {
+    return void 0;
+  }
+  return { length, sampleRate };
+}
+function estimateAdtsDurationMs(bytes) {
+  const first = readFrameAt(bytes, 0);
+  if (!first) {
+    return void 0;
+  }
+  let offset = 0;
+  let frameCount = 0;
+  while (offset < bytes.length) {
+    const frame2 = readFrameAt(bytes, offset);
+    if (!frame2) {
+      break;
+    }
+    frameCount++;
+    offset += frame2.length;
+  }
+  if (frameCount === 0) {
+    return void 0;
+  }
+  return frameCount * 1024 / first.sampleRate * 1e3;
+}
+var SAMPLE_RATES;
 var init_media_duration_adts = __esm({
   "src/core/utils/media-duration-adts.ts"() {
+    SAMPLE_RATES = [
+      96e3,
+      88200,
+      64e3,
+      48e3,
+      44100,
+      32e3,
+      24e3,
+      22050,
+      16e3,
+      12e3,
+      11025,
+      8e3,
+      7350
+    ];
   }
 });
+function readVInt(bytes, offset, keepMarker) {
+  if (offset >= bytes.length) {
+    return void 0;
+  }
+  const first = bytes[offset];
+  if (first === 0) {
+    return void 0;
+  }
+  let length = 1;
+  let mask = 128;
+  while (length <= 8 && (first & mask) === 0) {
+    mask >>= 1;
+    length++;
+  }
+  if (length > 8 || offset + length > bytes.length) {
+    return void 0;
+  }
+  let value = keepMarker ? first : first & mask - 1;
+  for (let i2 = 1; i2 < length; i2++) {
+    value = value * 256 + bytes[offset + i2];
+  }
+  return { value, length };
+}
+function readElementAt(bytes, offset) {
+  const idVint = readVInt(bytes, offset, true);
+  if (!idVint) {
+    return void 0;
+  }
+  const sizeVint = readVInt(bytes, offset + idVint.length, false);
+  if (!sizeVint) {
+    return void 0;
+  }
+  const dataStart = offset + idVint.length + sizeVint.length;
+  const allOnes = 2 ** (7 * sizeVint.length) - 1;
+  const dataEnd = sizeVint.value === allOnes ? bytes.length : dataStart + sizeVint.value;
+  return { id: idVint.value, dataStart, dataEnd: Math.min(dataEnd, bytes.length) };
+}
+function findChild2(bytes, start, end, id) {
+  let offset = start;
+  while (offset < end) {
+    const element = readElementAt(bytes, offset);
+    if (!element || element.dataEnd > end || element.dataEnd <= offset) {
+      return void 0;
+    }
+    if (element.id === id) {
+      return element;
+    }
+    offset = element.dataEnd;
+  }
+  return void 0;
+}
+function readUint(bytes, start, end) {
+  let value = 0;
+  for (let i2 = start; i2 < end; i2++) {
+    value = value * 256 + bytes[i2];
+  }
+  return value;
+}
+function readFloat(bytes, start, end) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const length = end - start;
+  if (length === 4) {
+    return view.getFloat32(start, false);
+  }
+  if (length === 8) {
+    return view.getFloat64(start, false);
+  }
+  return void 0;
+}
+function estimateEbmlDurationMs(bytes) {
+  const ebml = readElementAt(bytes, 0);
+  if (!ebml || ebml.id !== EBML_ID) {
+    return void 0;
+  }
+  const segment = findChild2(bytes, ebml.dataEnd, bytes.length, SEGMENT_ID);
+  if (!segment) {
+    return void 0;
+  }
+  const info = findChild2(bytes, segment.dataStart, segment.dataEnd, INFO_ID);
+  if (!info) {
+    return void 0;
+  }
+  const durationEl = findChild2(bytes, info.dataStart, info.dataEnd, DURATION_ID);
+  if (!durationEl) {
+    return void 0;
+  }
+  const duration = readFloat(bytes, durationEl.dataStart, durationEl.dataEnd);
+  if (duration === void 0) {
+    return void 0;
+  }
+  const scaleEl = findChild2(bytes, info.dataStart, info.dataEnd, TIMECODE_SCALE_ID);
+  const timecodeScaleNs = scaleEl ? readUint(bytes, scaleEl.dataStart, scaleEl.dataEnd) : 1e6;
+  return duration * timecodeScaleNs / 1e6;
+}
+var EBML_ID;
+var SEGMENT_ID;
+var INFO_ID;
+var TIMECODE_SCALE_ID;
+var DURATION_ID;
 var init_media_duration_ebml = __esm({
   "src/core/utils/media-duration-ebml.ts"() {
+    EBML_ID = 440786851;
+    SEGMENT_ID = 408125543;
+    INFO_ID = 357149030;
+    TIMECODE_SCALE_ID = 2807729;
+    DURATION_ID = 17545;
   }
 });
+function readBoxes(bytes, rangeStart, rangeEnd) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const boxes = [];
+  let offset = rangeStart;
+  while (offset + 8 <= rangeEnd) {
+    const size32 = view.getUint32(offset, false);
+    const type = String.fromCharCode(
+      bytes[offset + 4],
+      bytes[offset + 5],
+      bytes[offset + 6],
+      bytes[offset + 7]
+    );
+    let payloadStart = offset + 8;
+    let boxEnd;
+    if (size32 === 1) {
+      if (offset + 16 > rangeEnd) {
+        break;
+      }
+      const hi = view.getUint32(offset + 8, false);
+      const lo = view.getUint32(offset + 12, false);
+      boxEnd = offset + hi * 2 ** 32 + lo;
+      payloadStart = offset + 16;
+    } else if (size32 === 0) {
+      boxEnd = rangeEnd;
+    } else {
+      boxEnd = offset + size32;
+    }
+    if (boxEnd <= offset || boxEnd > rangeEnd) {
+      break;
+    }
+    boxes.push({ type, start: payloadStart, end: boxEnd });
+    offset = boxEnd;
+  }
+  return boxes;
+}
+function findBox(boxes, type) {
+  return boxes.find((b) => b.type === type);
+}
+function looksLikeIsoBmff(bytes) {
+  if (bytes.length < 12) {
+    return false;
+  }
+  return bytes[4] === 102 && bytes[5] === 116 && bytes[6] === 121 && bytes[7] === 112;
+}
+function estimateIsoBmffDurationMs(bytes) {
+  if (!looksLikeIsoBmff(bytes)) {
+    return void 0;
+  }
+  const top = readBoxes(bytes, 0, bytes.length);
+  const moov = findBox(top, "moov");
+  if (!moov) {
+    return void 0;
+  }
+  const moovChildren = readBoxes(bytes, moov.start, moov.end);
+  const mvhd = findBox(moovChildren, "mvhd");
+  if (!mvhd || mvhd.end - mvhd.start < 1) {
+    return void 0;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const version = bytes[mvhd.start];
+  let timescale;
+  let duration;
+  if (version === 1) {
+    if (mvhd.start + 32 > mvhd.end) {
+      return void 0;
+    }
+    timescale = view.getUint32(mvhd.start + 20, false);
+    const hi = view.getUint32(mvhd.start + 24, false);
+    const lo = view.getUint32(mvhd.start + 28, false);
+    duration = hi * 2 ** 32 + lo;
+  } else {
+    if (mvhd.start + 20 > mvhd.end) {
+      return void 0;
+    }
+    timescale = view.getUint32(mvhd.start + 12, false);
+    duration = view.getUint32(mvhd.start + 16, false);
+  }
+  if (!timescale) {
+    return void 0;
+  }
+  return duration / timescale * 1e3;
+}
 var init_media_duration_isobmff = __esm({
   "src/core/utils/media-duration-isobmff.ts"() {
   }
 });
+function skipId3v2(bytes) {
+  if (bytes.length < 10 || bytes[0] !== 73 || bytes[1] !== 68 || bytes[2] !== 51) {
+    return 0;
+  }
+  const size = (bytes[6] & 127) * 2097152 + (bytes[7] & 127) * 16384 + (bytes[8] & 127) * 128 + (bytes[9] & 127);
+  return 10 + size;
+}
+function findFirstFrame(bytes, start) {
+  for (let i2 = start; i2 + 4 <= bytes.length; i2++) {
+    if (bytes[i2] !== 255 || (bytes[i2 + 1] & 224) !== 224) {
+      continue;
+    }
+    const b1 = bytes[i2 + 1];
+    const b2 = bytes[i2 + 2];
+    const b3 = bytes[i2 + 3];
+    const versionId = b1 >> 3 & 3;
+    const layerId = b1 >> 1 & 3;
+    if (versionId === 1 || layerId !== 1) {
+      continue;
+    }
+    const bitrateIndex = b2 >> 4 & 15;
+    const sampleRateIndex = b2 >> 2 & 3;
+    if (bitrateIndex === 0 || bitrateIndex === 15 || sampleRateIndex === 3) {
+      continue;
+    }
+    const table2 = versionId === 3 ? BITRATE_TABLE["1-3"] : BITRATE_TABLE["2-3"];
+    const bitrateKbps = table2[bitrateIndex];
+    const sampleRate = SAMPLE_RATE_TABLE[versionId]?.[sampleRateIndex];
+    if (!sampleRate) {
+      continue;
+    }
+    const padding = b2 >> 1 & 1;
+    const channelMode = b3 >> 6 & 3;
+    const samplesPerFrame = versionId === 3 ? 1152 : 576;
+    const frameLength = Math.floor(samplesPerFrame / 8 * (bitrateKbps * 1e3)) / sampleRate + padding;
+    return {
+      offset: i2,
+      versionId,
+      bitrateKbps,
+      sampleRate,
+      channelMode,
+      padding,
+      frameLength: Math.floor(frameLength)
+    };
+  }
+  return void 0;
+}
+function readXingFrameCount(bytes, frame2) {
+  const sideInfoSize = frame2.versionId === 3 ? frame2.channelMode === 3 ? 17 : 32 : frame2.channelMode === 3 ? 9 : 17;
+  const tagStart = frame2.offset + 4 + sideInfoSize;
+  if (tagStart + 8 > bytes.length) {
+    return void 0;
+  }
+  const tag = String.fromCharCode(
+    bytes[tagStart],
+    bytes[tagStart + 1],
+    bytes[tagStart + 2],
+    bytes[tagStart + 3]
+  );
+  if (tag !== "Xing" && tag !== "Info") {
+    return void 0;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const flags = view.getUint32(tagStart + 4, false);
+  if ((flags & 1) === 0) {
+    return void 0;
+  }
+  return view.getUint32(tagStart + 8, false);
+}
+function readVbriFrameCount(bytes, frame2) {
+  const tagStart = frame2.offset + 4 + 32;
+  if (tagStart + 14 > bytes.length) {
+    return void 0;
+  }
+  const tag = String.fromCharCode(
+    bytes[tagStart],
+    bytes[tagStart + 1],
+    bytes[tagStart + 2],
+    bytes[tagStart + 3]
+  );
+  if (tag !== "VBRI") {
+    return void 0;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return view.getUint32(tagStart + 14, false);
+}
+function estimateMp3DurationMs(bytes) {
+  const start = skipId3v2(bytes);
+  const frame2 = findFirstFrame(bytes, start);
+  if (!frame2) {
+    return void 0;
+  }
+  const samplesPerFrame = frame2.versionId === 3 ? 1152 : 576;
+  const xingFrames = readXingFrameCount(bytes, frame2);
+  if (xingFrames !== void 0) {
+    return xingFrames * samplesPerFrame / frame2.sampleRate * 1e3;
+  }
+  const vbriFrames = readVbriFrameCount(bytes, frame2);
+  if (vbriFrames !== void 0) {
+    return vbriFrames * samplesPerFrame / frame2.sampleRate * 1e3;
+  }
+  const audioBytes = bytes.length - frame2.offset;
+  if (frame2.bitrateKbps <= 0) {
+    return void 0;
+  }
+  return audioBytes * 8 / (frame2.bitrateKbps * 1e3) * 1e3;
+}
+var BITRATE_TABLE;
+var SAMPLE_RATE_TABLE;
 var init_media_duration_mp3 = __esm({
   "src/core/utils/media-duration-mp3.ts"() {
+    BITRATE_TABLE = {
+      // MPEG version 1, Layer III (kbps), index 0 = "free", 15 = "bad".
+      "1-3": [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0],
+      // MPEG version 2/2.5, Layer III.
+      "2-3": [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0]
+    };
+    SAMPLE_RATE_TABLE = {
+      0: [11025, 12e3, 8e3],
+      // MPEG 2.5
+      2: [22050, 24e3, 16e3],
+      // MPEG 2
+      3: [44100, 48e3, 32e3]
+      // MPEG 1
+    };
   }
 });
+function matchesAt(bytes, offset, pattern) {
+  if (offset + pattern.length > bytes.length) {
+    return false;
+  }
+  for (let i2 = 0; i2 < pattern.length; i2++) {
+    if (bytes[offset + i2] !== pattern[i2]) {
+      return false;
+    }
+  }
+  return true;
+}
+function readPageAt(bytes, offset) {
+  if (!matchesAt(bytes, offset, OGG_CAPTURE)) {
+    return void 0;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const lo = view.getUint32(offset + 6, true);
+  const hi = view.getUint32(offset + 10, true);
+  const granulePosition = hi * 2 ** 32 + lo;
+  const pageSegments = bytes[offset + 26];
+  const segmentTableStart = offset + 27;
+  let dataLength = 0;
+  for (let i2 = 0; i2 < pageSegments; i2++) {
+    dataLength += bytes[segmentTableStart + i2];
+  }
+  const dataStart = segmentTableStart + pageSegments;
+  return { granulePosition, dataStart, dataEnd: dataStart + dataLength };
+}
+function detectCodecSampleRate(bytes, page) {
+  const start = page.dataStart;
+  if (matchesAt(bytes, start, [79, 112, 117, 115, 72, 101, 97, 100])) {
+    return { opus: true, sampleRate: 48e3 };
+  }
+  if (matchesAt(bytes, start + 1, [118, 111, 114, 98, 105, 115])) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const sampleRate = view.getUint32(start + 1 + 6 + 4 + 1, true);
+    return { opus: false, sampleRate };
+  }
+  return void 0;
+}
+function estimateOggDurationMs(bytes) {
+  if (!matchesAt(bytes, 0, OGG_CAPTURE)) {
+    return void 0;
+  }
+  const firstPage = readPageAt(bytes, 0);
+  if (!firstPage) {
+    return void 0;
+  }
+  const codec = detectCodecSampleRate(bytes, firstPage);
+  if (!codec || !codec.sampleRate) {
+    return void 0;
+  }
+  let lastPageOffset;
+  for (let i2 = bytes.length - OGG_CAPTURE.length; i2 >= 0; i2--) {
+    if (matchesAt(bytes, i2, OGG_CAPTURE)) {
+      lastPageOffset = i2;
+      break;
+    }
+  }
+  if (lastPageOffset === void 0) {
+    return void 0;
+  }
+  const lastPage = readPageAt(bytes, lastPageOffset);
+  if (!lastPage || lastPage.granulePosition <= 0) {
+    return void 0;
+  }
+  return lastPage.granulePosition / codec.sampleRate * 1e3;
+}
+var OGG_CAPTURE;
 var init_media_duration_ogg = __esm({
   "src/core/utils/media-duration-ogg.ts"() {
+    OGG_CAPTURE = [79, 103, 103, 83];
   }
 });
+function estimateWavDurationMs(bytes) {
+  if (bytes.length < 12) {
+    return void 0;
+  }
+  const isRiff = bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70;
+  const isWave = bytes[8] === 87 && bytes[9] === 65 && bytes[10] === 86 && bytes[11] === 69;
+  if (!isRiff || !isWave) {
+    return void 0;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 12;
+  let byteRate;
+  let dataSize;
+  while (offset + 8 <= bytes.length) {
+    const id = String.fromCharCode(
+      bytes[offset],
+      bytes[offset + 1],
+      bytes[offset + 2],
+      bytes[offset + 3]
+    );
+    const size = view.getUint32(offset + 4, true);
+    const dataStart = offset + 8;
+    if (id === "fmt " && dataStart + 16 <= bytes.length) {
+      byteRate = view.getUint32(dataStart + 8, true);
+    } else if (id === "data") {
+      dataSize = size;
+    }
+    if (byteRate !== void 0 && dataSize !== void 0) {
+      break;
+    }
+    offset = dataStart + size + size % 2;
+  }
+  if (!byteRate || dataSize === void 0) {
+    return void 0;
+  }
+  return dataSize / byteRate * 1e3;
+}
 var init_media_duration_wav = __esm({
   "src/core/utils/media-duration-wav.ts"() {
   }
 });
+function estimateMediaDurationMs(bytes) {
+  if (bytes.length < 4) {
+    return void 0;
+  }
+  try {
+    if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70) {
+      return estimateWavDurationMs(bytes);
+    }
+    if (bytes[0] === 79 && bytes[1] === 103 && bytes[2] === 103 && bytes[3] === 83) {
+      return estimateOggDurationMs(bytes);
+    }
+    if (bytes[0] === 26 && bytes[1] === 69 && bytes[2] === 223 && bytes[3] === 163) {
+      return estimateEbmlDurationMs(bytes);
+    }
+    if (looksLikeIsoBmff(bytes)) {
+      return estimateIsoBmffDurationMs(bytes);
+    }
+    if (bytes[0] === 73 && bytes[1] === 68 && bytes[2] === 51) {
+      return estimateMp3DurationMs(bytes);
+    }
+    if (bytes[0] === 255 && (bytes[1] & 224) === 224) {
+      const mp3 = estimateMp3DurationMs(bytes);
+      if (mp3 !== void 0) {
+        return mp3;
+      }
+      return estimateAdtsDurationMs(bytes);
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
 var init_media_duration = __esm({
   "src/core/utils/media-duration.ts"() {
     init_media_duration_adts();
@@ -64639,7 +66717,7 @@ var init_PptxTableDataParser = __esm({
           const xmlRows = this.context.ensureArray(tableNode["a:tr"]);
           const rows = xmlRows.map((rowNode) => {
             const rowHeightEmu = parseInt(String(rowNode?.["@_h"] || "0"), 10) || 0;
-            const rowHeight = Math.round(rowHeightEmu / this.context.emuPerPx);
+            const rowHeight = rowHeightEmu / this.context.emuPerPx;
             const xmlCells = this.context.ensureArray(rowNode["a:tc"]);
             return {
               height: rowHeight,
@@ -65449,15 +67527,15 @@ function readPositiveInteger(value) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
 }
 function getTableGridExtent(graphicData) {
-  const table = graphicData?.["a:tbl"];
-  if (!table) {
+  const table2 = graphicData?.["a:tbl"];
+  if (!table2) {
     return void 0;
   }
-  const grid = table["a:tblGrid"];
+  const grid = table2["a:tblGrid"];
   const widthEmu = ensureArrayLike2(
     grid?.["a:gridCol"]
   ).reduce((sum, column) => sum + readPositiveInteger(column?.["@_w"]), 0);
-  const heightEmu = ensureArrayLike2(table["a:tr"]).reduce(
+  const heightEmu = ensureArrayLike2(table2["a:tr"]).reduce(
     (sum, row) => sum + readPositiveInteger(row?.["@_h"]),
     0
   );
@@ -69808,6 +71886,139 @@ var init_animation_timeline_anchors = __esm({
     init_animation_timing_ownership();
   }
 });
+function patchMediaCallDuration(animations, rawShapeId, realMs, remap) {
+  const roundedReal = Math.round(realMs);
+  for (const anim of animations) {
+    if (anim.kind === "media" || anim.targetId !== rawShapeId) {
+      continue;
+    }
+    const oldMs = anim.durationMs;
+    if (oldMs === void 0 || oldMs <= 0 || oldMs === roundedReal) {
+      continue;
+    }
+    anim.durationMs = roundedReal;
+    const existing = remap.get(oldMs);
+    if (existing === void 0) {
+      remap.set(oldMs, roundedReal);
+    } else if (existing !== roundedReal) {
+      remap.delete(oldMs);
+    }
+  }
+}
+function applyPlainDelayRemap(animations, remap) {
+  if (remap.size === 0) {
+    return;
+  }
+  for (const anim of animations) {
+    if (anim.parGroupDelayMs !== void 0) {
+      const real = remap.get(anim.parGroupDelayMs);
+      if (real !== void 0) {
+        anim.parGroupDelayMs = real;
+      }
+    }
+    for (const conditions of [anim.startConditions, anim.endConditions]) {
+      if (!conditions) {
+        continue;
+      }
+      for (const cond of conditions) {
+        if (cond.event !== void 0 || cond.targetTimeNodeId !== void 0 || cond.targetShapeId !== void 0 || typeof cond.delay !== "number" || cond.delay <= 0) {
+          continue;
+        }
+        const real = remap.get(cond.delay);
+        if (real !== void 0) {
+          cond.delay = real;
+        }
+      }
+    }
+  }
+}
+var init_native_animation_media_duration_plain_delay = __esm({
+  "src/core/services/native-animation-media-duration-plain-delay.ts"() {
+  }
+});
+function isMediaElement(el) {
+  return el.type === "media";
+}
+function collectMediaElementsByRawId(elements2) {
+  const map = /* @__PURE__ */ new Map();
+  const walk2 = (els) => {
+    for (const el of els) {
+      if (isMediaElement(el) && el.mediaPath) {
+        const rawId = readCnvPrId(el.rawXml);
+        if (rawId) {
+          map.set(rawId, el);
+        }
+      }
+      if (el.type === "group" && Array.isArray(el.children)) {
+        walk2(el.children);
+      }
+    }
+  };
+  walk2(elements2);
+  return map;
+}
+function patchOnStopAudioConditions(animations, nodeId, rawShapeId, realMs) {
+  for (const anim of animations) {
+    for (const conditions of [anim.startConditions, anim.endConditions]) {
+      if (!conditions) {
+        continue;
+      }
+      for (const cond of conditions) {
+        if (cond.event !== "onStopAudio") {
+          continue;
+        }
+        const namesThisNode = nodeId !== void 0 && cond.targetTimeNodeId === nodeId || cond.targetShapeId === rawShapeId;
+        if (namesThisNode) {
+          cond.delay = Math.round(realMs);
+        }
+      }
+    }
+  }
+}
+async function attachRealMediaDurations(elements2, nativeAnimations, readBytes) {
+  if (!nativeAnimations || nativeAnimations.length === 0) {
+    return;
+  }
+  const mediaByRawId = collectMediaElementsByRawId(elements2);
+  if (mediaByRawId.size === 0) {
+    return;
+  }
+  const plainDelayRemap = /* @__PURE__ */ new Map();
+  for (const anim of nativeAnimations) {
+    if (anim.kind !== "media" || anim.targetId === void 0) {
+      continue;
+    }
+    const element = mediaByRawId.get(anim.targetId);
+    if (!element?.mediaPath) {
+      continue;
+    }
+    let bytes;
+    try {
+      bytes = await readBytes(element.mediaPath);
+    } catch {
+      continue;
+    }
+    if (!bytes) {
+      continue;
+    }
+    const realMs = estimateMediaDurationMs(bytes);
+    if (realMs === void 0 || !Number.isFinite(realMs) || realMs <= 0) {
+      continue;
+    }
+    anim.durationMs = Math.round(realMs);
+    element.metadata = { ...element.metadata, duration: realMs / 1e3 };
+    patchOnStopAudioConditions(nativeAnimations, anim.nodeId, anim.targetId, realMs);
+    patchMediaCallDuration(nativeAnimations, anim.targetId, realMs, plainDelayRemap);
+  }
+  applyPlainDelayRemap(nativeAnimations, plainDelayRemap);
+}
+var init_native_animation_media_duration = __esm({
+  "src/core/services/native-animation-media-duration.ts"() {
+    init_media_duration();
+    init_animation_target_reconcile();
+    init_native_animation_media_duration_plain_delay();
+  }
+});
 function asNode3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
@@ -69848,6 +72059,7 @@ var init_PptxSlideLoaderService = __esm({
     init_animation_sound_merge();
     init_animation_target_reconcile();
     init_animation_timeline_anchors();
+    init_native_animation_media_duration();
     init_slide_name();
     PptxSlideLoaderService = class {
       /**
@@ -70039,6 +72251,17 @@ var init_PptxSlideLoaderService = __esm({
             animations = timeline.animations;
             animationTimelineAnchors = timeline.anchors.length > 0 ? timeline.anchors : void 0;
           }
+          await attachRealMediaDurations(elements2, nativeAnimations, async (mediaPath) => {
+            const file = params.zip.file(mediaPath);
+            if (!file) {
+              return void 0;
+            }
+            try {
+              return await file.async("uint8array");
+            } catch {
+              return void 0;
+            }
+          });
           reconcileAnimationTargets(elements2, nativeAnimations, animations, animationTimelineAnchors);
           mergeNativeSoundIntoEditorAnimations(nativeAnimations, animations);
           mergeNativeBuildTemplatesIntoEditorAnimations(nativeAnimations, animations);
@@ -83078,28 +85301,28 @@ function applyChartDataTable(plotArea, dataTable, localName28, resolveColor2) {
     }
     return;
   }
-  const table = {
+  const table2 = {
     ...tableKey ? plotArea[tableKey] : void 0
   };
   for (const flag of FLAGS2) {
     const value = dataTable[flag];
     if (value !== void 0) {
-      setOrdered4(table, flag, { "@_val": value ? "1" : "0" }, TABLE_ORDER, localName28);
+      setOrdered4(table2, flag, { "@_val": value ? "1" : "0" }, TABLE_ORDER, localName28);
     }
   }
   if (dataTable.spPr) {
-    const spPrKey = findKey14(table, "spPr", localName28);
+    const spPrKey = findKey14(table2, "spPr", localName28);
     const spPr = writeChartShapeProps(
-      spPrKey ? table[spPrKey] : void 0,
+      spPrKey ? table2[spPrKey] : void 0,
       dataTable.spPr,
       localName28,
       resolveColor2
     );
-    setOrdered4(table, "spPr", spPr, TABLE_ORDER, localName28);
+    setOrdered4(table2, "spPr", spPr, TABLE_ORDER, localName28);
   }
   if (dataTable.txPr) {
-    const txPrKey = findKey14(table, "txPr", localName28);
-    const authoredDefRPr = resolveTxPrDefRPr(txPrKey ? table[txPrKey] : void 0, {
+    const txPrKey = findKey14(table2, "txPr", localName28);
+    const authoredDefRPr = resolveTxPrDefRPr(txPrKey ? table2[txPrKey] : void 0, {
       getChildByLocalName: (parent, name) => {
         if (!parent) {
           return void 0;
@@ -83110,13 +85333,13 @@ function applyChartDataTable(plotArea, dataTable, localName28, resolveColor2) {
     });
     const txPr = buildDefRPrTextProperties(dataTable.txPr, authoredDefRPr, resolveColor2);
     if (txPr) {
-      setOrdered4(table, "txPr", txPr, TABLE_ORDER, localName28);
+      setOrdered4(table2, "txPr", txPr, TABLE_ORDER, localName28);
     }
   }
   if (tableKey) {
-    plotArea[tableKey] = table;
+    plotArea[tableKey] = table2;
   } else {
-    setOrdered4(plotArea, "dTable", table, PLOT_AREA_ORDER, localName28);
+    setOrdered4(plotArea, "dTable", table2, PLOT_AREA_ORDER, localName28);
   }
 }
 var TABLE_ORDER;
@@ -89103,10 +91326,10 @@ function buildImageEffectsFilter(effects, idSuffix) {
   }
   if (typeof effects.biLevel === "number") {
     next("p6a", `<feColorMatrix in="__IN__" type="saturate" values="0" result="__OUT__"/>`);
-    const table = biLevelTable(effects.biLevel);
+    const table2 = biLevelTable(effects.biLevel);
     next(
       "p6b",
-      `<feComponentTransfer in="__IN__" result="__OUT__"><feFuncR type="discrete" tableValues="${table}"/><feFuncG type="discrete" tableValues="${table}"/><feFuncB type="discrete" tableValues="${table}"/></feComponentTransfer>`
+      `<feComponentTransfer in="__IN__" result="__OUT__"><feFuncR type="discrete" tableValues="${table2}"/><feFuncG type="discrete" tableValues="${table2}"/><feFuncB type="discrete" tableValues="${table2}"/></feComponentTransfer>`
     );
   }
   if (effects.duotone) {
@@ -96978,11 +99201,11 @@ function updateCellTextInRawXml(element, rowIndex, colIndex, text22) {
     return void 0;
   }
   const newRawXml = structuredClone(element.rawXml);
-  const table = getTblFromRawXml(newRawXml);
-  if (!table) {
+  const table2 = getTblFromRawXml(newRawXml);
+  if (!table2) {
     return void 0;
   }
-  const rows = ensureArray19(table["a:tr"]);
+  const rows = ensureArray19(table2["a:tr"]);
   if (rowIndex < 0 || rowIndex >= rows.length) {
     return void 0;
   }
@@ -97028,11 +99251,11 @@ function updateCellTextStyleInRawXml(element, rowIndex, colIndex, styleUpdates)
     return void 0;
   }
   const newRawXml = structuredClone(element.rawXml);
-  const table = getTblFromRawXml(newRawXml);
-  if (!table) {
+  const table2 = getTblFromRawXml(newRawXml);
+  if (!table2) {
     return void 0;
   }
-  const rows = ensureArray19(table["a:tr"]);
+  const rows = ensureArray19(table2["a:tr"]);
   if (rowIndex < 0 || rowIndex >= rows.length) {
     return void 0;
   }
@@ -97130,11 +99353,11 @@ function updateMergeAttrsInRawXml(element, tableData) {
     return void 0;
   }
   const newRawXml = structuredClone(element.rawXml);
-  const table = getTblFromRawXml(newRawXml);
-  if (!table) {
+  const table2 = getTblFromRawXml(newRawXml);
+  if (!table2) {
     return void 0;
   }
-  const xmlRows = ensureArray19(table["a:tr"]);
+  const xmlRows = ensureArray19(table2["a:tr"]);
   for (let rIdx = 0; rIdx < Math.min(tableData.rows.length, xmlRows.length); rIdx++) {
     const dataRow = tableData.rows[rIdx];
     const xmlCells = ensureArray19(xmlRows[rIdx]["a:tc"]);
@@ -97188,12 +99411,12 @@ function rebuildTableStructureInRawXml(element, tableData) {
     return void 0;
   }
   const newRawXml = structuredClone(element.rawXml);
-  const table = getTblFromRawXml(newRawXml);
-  if (!table) {
+  const table2 = getTblFromRawXml(newRawXml);
+  if (!table2) {
     return void 0;
   }
   const existingGridCols = ensureArray19(
-    table["a:tblGrid"]?.["a:gridCol"]
+    table2["a:tblGrid"]?.["a:gridCol"]
   );
   const totalWidthEmu = existingGridCols.reduce((sum, col) => {
     return sum + (parseInt(String(col?.["@_w"] || "0"), 10) || 0);
@@ -97201,11 +99424,11 @@ function rebuildTableStructureInRawXml(element, tableData) {
   const newGridCols = tableData.columnWidths.map((w) => ({
     "@_w": String(Math.round(w * totalWidthEmu))
   }));
-  if (!table["a:tblGrid"]) {
-    table["a:tblGrid"] = {};
+  if (!table2["a:tblGrid"]) {
+    table2["a:tblGrid"] = {};
   }
-  table["a:tblGrid"]["a:gridCol"] = newGridCols.length === 1 ? newGridCols[0] : newGridCols;
-  const existingXmlRows = ensureArray19(table["a:tr"]);
+  table2["a:tblGrid"]["a:gridCol"] = newGridCols.length === 1 ? newGridCols[0] : newGridCols;
+  const existingXmlRows = ensureArray19(table2["a:tr"]);
   const newXmlRows = tableData.rows.map((dataRow, ri) => {
     const existingRow = ri < existingXmlRows.length ? existingXmlRows[ri] : void 0;
     const existingCells = existingRow ? ensureArray19(existingRow["a:tc"]) : [];
@@ -97244,7 +99467,7 @@ function rebuildTableStructureInRawXml(element, tableData) {
       "a:tc": newXmlCells.length === 1 ? newXmlCells[0] : newXmlCells
     };
   });
-  table["a:tr"] = newXmlRows.length === 1 ? newXmlRows[0] : newXmlRows;
+  table2["a:tr"] = newXmlRows.length === 1 ? newXmlRows[0] : newXmlRows;
   return newRawXml;
 }
 var init_table_cell_rawxml_ops = __esm({
@@ -136085,8 +138308,8 @@ function applyTableCellImagePatches(elements, resolvedMap, refs) {
     if (!cellPatches || el.type !== "table") {
       return el;
     }
-    const table = el;
-    const tableData = table.tableData;
+    const table2 = el;
+    const tableData = table2.tableData;
     if (!tableData) {
       return el;
     }
@@ -136107,7 +138330,7 @@ function applyTableCellImagePatches(elements, resolvedMap, refs) {
       });
       return { ...row, cells: newCells };
     });
-    return { ...table, tableData: { ...tableData, rows: newRows } };
+    return { ...table2, tableData: { ...tableData, rows: newRows } };
   });
 }
 function buildInitialGuides(presentationGuides, firstSlideGuides) {
@@ -139332,9 +141555,9 @@ function buildImageAlphaFilterMarkup(effects) {
   }
   if (typeof effects.alphaBiLevel === "number") {
     const t = clamp32(effects.alphaBiLevel / 100, 0, 1);
-    const table = Array.from({ length: 10 }, (_, i2) => i2 / 10 >= t ? "1" : "0").join(" ");
+    const table2 = Array.from({ length: 10 }, (_, i2) => i2 / 10 >= t ? "1" : "0").join(" ");
     next(
-      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncA type="discrete" tableValues="${table}"/></feComponentTransfer>`
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncA type="discrete" tableValues="${table2}"/></feComponentTransfer>`
     );
   }
   if (typeof effects.biLevel === "number") {
@@ -143448,7 +145671,7 @@ function notifyBarFacePicturePixelListeners() {
 function getBarFacePicturePixelSampleVersion() {
   return sampleVersion;
 }
-function hexChannel(value) {
+function hexChannel2(value) {
   return Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0");
 }
 function decodeFirstPixelColor(imageUrl) {
@@ -143470,7 +145693,7 @@ function decodeFirstPixelColor(imageUrl) {
         }
         ctx.drawImage(img, 0, 0, 1, 1, 0, 0, 1, 1);
         const [r, g2, b, a] = ctx.getImageData(0, 0, 1, 1).data;
-        resolve2(a === 0 ? void 0 : `#${hexChannel(r)}${hexChannel(g2)}${hexChannel(b)}`);
+        resolve2(a === 0 ? void 0 : `#${hexChannel2(r)}${hexChannel2(g2)}${hexChannel2(b)}`);
       } catch {
         resolve2(void 0);
       }
@@ -143494,6 +145717,33 @@ function ensureBarFacePicturePixelSampled(imageUrl, sampler = decodeFirstPixelCo
   });
   inFlight.set(imageUrl, pending);
 }
+function trySampleFirstPixelColorSync(imageUrl) {
+  const parsed = parseDataUrlToBytes(imageUrl);
+  if (!parsed) {
+    return void 0;
+  }
+  try {
+    return sampleFirstPixelColorFromBytes(parsed.bytes);
+  } catch {
+    return void 0;
+  }
+}
+function resolveBarFacePicturePixelColor(imageUrl) {
+  const cached = getCachedBarFacePicturePixelColor(imageUrl);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (sampleCache.has(imageUrl) || inFlight.has(imageUrl)) {
+    return void 0;
+  }
+  const sync = trySampleFirstPixelColorSync(imageUrl);
+  if (sync !== void 0) {
+    sampleCache.set(imageUrl, sync);
+    return sync;
+  }
+  ensureBarFacePicturePixelSampled(imageUrl);
+  return void 0;
+}
 function resolveUntargetedBarFaceFill(face, baseColor) {
   return face === "end" ? tint2(baseColor, 0.22) : shade2(baseColor, 0.25);
 }
@@ -143529,11 +145779,10 @@ function resolveExtrusionFaceFill(facePoints, face, resolvedColor, rect22, pictu
   if (!activePicture?.imageUrl) {
     return fallback;
   }
-  const sampled = getCachedBarFacePicturePixelColor(activePicture.imageUrl);
+  const sampled = resolveBarFacePicturePixelColor(activePicture.imageUrl);
   if (sampled !== void 0) {
     return resolveUntargetedBarFaceFill(face, sampled);
   }
-  ensureBarFacePicturePixelSampled(activePicture.imageUrl);
   return fallback;
 }
 var LEGEND_ITEM_WIDTH = 80;
@@ -145356,8 +147605,8 @@ var DEFAULT_CELL_FONT_PX = 8;
 var DEFAULT_BORDER_COLOR = "#cbd5e1";
 var DEFAULT_TEXT_COLOR22 = "#334155";
 function computeDataTablePrimitives(chartData, layout, colorPalette) {
-  const table = chartData.dataTable;
-  if (!table) {
+  const table2 = chartData.dataTable;
+  if (!table2) {
     return [];
   }
   const categories = chartData.categories;
@@ -145366,18 +147615,18 @@ function computeDataTablePrimitives(chartData, layout, colorPalette) {
     return [];
   }
   const out = [];
-  const showH = table.showHorzBorder !== false;
-  const showV = table.showVertBorder !== false;
-  const showO = table.showOutline !== false;
-  const showK = table.showKeys !== false;
-  const borderColor = table.spPr?.strokeColor ?? DEFAULT_BORDER_COLOR;
-  const borderWidth = table.spPr?.strokeWidth ?? 1;
-  const textColor = table.txPr?.color ?? DEFAULT_TEXT_COLOR22;
-  const fontFamily = table.txPr?.fontFamily;
-  const fontSize = table.txPr?.fontSize !== void 0 ? chartFontPx(table.txPr.fontSize) : DEFAULT_CELL_FONT_PX;
-  const headerWeight = table.txPr?.bold === false ? "normal" : "bold";
-  const cellWeight = table.txPr?.bold ? "bold" : "normal";
-  const fontStyle = table.txPr?.italic ? "italic" : "normal";
+  const showH = table2.showHorzBorder !== false;
+  const showV = table2.showVertBorder !== false;
+  const showO = table2.showOutline !== false;
+  const showK = table2.showKeys !== false;
+  const borderColor = table2.spPr?.strokeColor ?? DEFAULT_BORDER_COLOR;
+  const borderWidth = table2.spPr?.strokeWidth ?? 1;
+  const textColor = table2.txPr?.color ?? DEFAULT_TEXT_COLOR22;
+  const fontFamily = table2.txPr?.fontFamily;
+  const fontSize = table2.txPr?.fontSize !== void 0 ? chartFontPx(table2.txPr.fontSize) : DEFAULT_CELL_FONT_PX;
+  const headerWeight = table2.txPr?.bold === false ? "normal" : "bold";
+  const cellWeight = table2.txPr?.bold ? "bold" : "normal";
+  const fontStyle = table2.txPr?.italic ? "italic" : "normal";
   const catCount = categories.length;
   const seriesCount = series.length;
   const keyColW = showK ? DATA_TABLE_KEY_W : 0;
@@ -145385,14 +147634,14 @@ function computeDataTablePrimitives(chartData, layout, colorPalette) {
   const cellW = catCount > 0 ? (totalW - keyColW) / catCount : totalW - keyColW;
   const tableTop = layout.plotBottom + DATA_TABLE_PADDING;
   const tableH = DATA_TABLE_HEADER_H + seriesCount * DATA_TABLE_ROW_H;
-  if (table.spPr?.fillColor) {
+  if (table2.spPr?.fillColor) {
     out.push({
       kind: "rect",
       x: layout.plotLeft,
       y: tableTop,
       w: totalW,
       h: tableH,
-      fill: table.spPr.fillColor
+      fill: table2.spPr.fillColor
     });
   }
   if (showO) {
@@ -188201,8 +190450,8 @@ var LABEL_KEYS = {
 function entry(id, extra = {}) {
   return { id, labelKey: LABEL_KEYS[id], ...extra };
 }
-function tableEntries(table) {
-  if (!table) {
+function tableEntries(table2) {
+  if (!table2) {
     return [];
   }
   const rowsAndColumns = [
@@ -188213,10 +190462,10 @@ function tableEntries(table) {
     entry("table-insert-col-right"),
     entry("table-delete-col")
   ];
-  if (table.hasMultiCellSelection) {
+  if (table2.hasMultiCellSelection) {
     return [...rowsAndColumns, entry("table-merge-selected", { separatorBefore: true })];
   }
-  if (table.isMergedCell) {
+  if (table2.isMergedCell) {
     return [...rowsAndColumns, entry("table-split", { separatorBefore: true })];
   }
   return [
@@ -188226,7 +190475,7 @@ function tableEntries(table) {
   ];
 }
 function buildContextMenuEntries(context = {}) {
-  const { elementType, table, hasMultiSelection, aiEnabled, hasClipboard, selectionGroupable } = context;
+  const { elementType, table: table2, hasMultiSelection, aiEnabled, hasClipboard, selectionGroupable } = context;
   const lockedOut = selectionGroupable === false;
   const entries = [
     entry("copy"),
@@ -188242,7 +190491,7 @@ function buildContextMenuEntries(context = {}) {
     entries.push(entry("ai-ask", { separatorBefore: true }), entry("ai-fix"));
   }
   entries.push(entry("comment", { separatorBefore: true }), entry("hyperlink"));
-  entries.push(...tableEntries(table));
+  entries.push(...tableEntries(table2));
   if (hasMultiSelection) {
     entries.push(
       entry("group", { separatorBefore: true, ...lockedOut ? { disabled: true } : {} })
@@ -195643,6 +197892,262 @@ function applyBackgroundEdit(entry2, edit) {
     payload: { styleId: entry2.styleId, section: "background" }
   };
 }
+var MIN_TILE_DIM = 256;
+function computeExportTilePlan(fullWidth, fullHeight, maxDim) {
+  const safeMax = Math.max(MIN_TILE_DIM, Math.floor(maxDim));
+  const fw = Math.max(1, Math.round(fullWidth));
+  const fh = Math.max(1, Math.round(fullHeight));
+  if (fw <= safeMax && fh <= safeMax) {
+    return {
+      fullWidth: fw,
+      fullHeight: fh,
+      tiled: false,
+      cols: 1,
+      rows: 1,
+      tiles: [{ col: 0, row: 0, x: 0, y: 0, width: fw, height: fh }]
+    };
+  }
+  const cols = Math.ceil(fw / safeMax);
+  const rows = Math.ceil(fh / safeMax);
+  const baseTileW = Math.ceil(fw / cols);
+  const baseTileH = Math.ceil(fh / rows);
+  const tiles = [];
+  for (let row = 0; row < rows; row++) {
+    const y = row * baseTileH;
+    const height = Math.min(baseTileH, fh - y);
+    for (let col = 0; col < cols; col++) {
+      const x = col * baseTileW;
+      const width = Math.min(baseTileW, fw - x);
+      tiles.push({ col, row, x, y, width, height });
+    }
+  }
+  return { fullWidth: fw, fullHeight: fh, tiled: true, cols, rows, tiles };
+}
+function tileRectToSourceRect(tile, scale2) {
+  const s = scale2 > 0 ? scale2 : 1;
+  return {
+    x: tile.x / s,
+    y: tile.y / s,
+    width: tile.width / s,
+    height: tile.height / s
+  };
+}
+var EXCLUDED_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
+  "cursor",
+  "caret-color",
+  "user-select",
+  "-webkit-user-select",
+  "all"
+]);
+function buildInlineStyleText(computed) {
+  const parts = [];
+  for (let i2 = 0; i2 < computed.length; i2++) {
+    const prop = computed.item(i2);
+    if (EXCLUDED_STYLE_PROPERTIES.has(prop)) {
+      continue;
+    }
+    const value = computed.getPropertyValue(prop);
+    if (!value) {
+      continue;
+    }
+    parts.push(`${prop}:${value}`);
+  }
+  return parts.join(";");
+}
+function inlineComputedStylesOnClone(liveRoot, cloneRoot, readComputedStyle) {
+  const liveEl = liveRoot;
+  const cloneEl = cloneRoot;
+  cloneEl.setAttribute("style", buildInlineStyleText(readComputedStyle(liveEl)));
+  const liveChildren = liveRoot.children;
+  const cloneChildren = cloneRoot.children;
+  const count = Math.min(liveChildren.length, cloneChildren.length);
+  for (let i2 = 0; i2 < count; i2++) {
+    inlineComputedStylesOnClone(liveChildren[i2], cloneChildren[i2], readComputedStyle);
+  }
+}
+function collectFontFaceCss(doc) {
+  const blocks = [];
+  const styles = doc.querySelectorAll("style");
+  for (let i2 = 0; i2 < styles.length; i2++) {
+    const text22 = styles[i2].textContent ?? "";
+    if (text22.includes("@font-face")) {
+      blocks.push(text22);
+    }
+  }
+  return blocks.join("\n\n");
+}
+async function fetchTextIfCrossOriginSafe(url) {
+  try {
+    const response = await fetch(url, { mode: "cors" });
+    if (!response.ok) {
+      return null;
+    }
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+var FONT_FACE_URL_PATTERN = /url\(\s*["']?([^"')]+)["']?\s*\)/gu;
+async function inlineFontFaceUrls(css, fetchDataUrl) {
+  const urls = /* @__PURE__ */ new Set();
+  for (const match of css.matchAll(FONT_FACE_URL_PATTERN)) {
+    const raw = match[1];
+    if (raw.startsWith("http:") || raw.startsWith("https:")) {
+      urls.add(raw);
+    }
+  }
+  if (urls.size === 0) {
+    return { css, allEmbedded: true };
+  }
+  const resolved = await Promise.all(
+    Array.from(urls, async (url) => [url, await fetchDataUrl(url)])
+  );
+  let inlined = css;
+  let allEmbedded = true;
+  for (const [url, dataUrl] of resolved) {
+    if (dataUrl) {
+      inlined = inlined.split(url).join(dataUrl);
+    } else {
+      allEmbedded = false;
+    }
+  }
+  return { css: inlined, allEmbedded };
+}
+async function collectExternalFontFaceCss(doc, fetchDataUrl) {
+  const links = doc.querySelectorAll('link[rel="stylesheet"]');
+  const blocks = [];
+  let allEmbedded = true;
+  for (let i2 = 0; i2 < links.length; i2++) {
+    const href = links[i2].getAttribute("href");
+    if (!href || !(href.startsWith("http:") || href.startsWith("https:"))) {
+      continue;
+    }
+    const css = await fetchTextIfCrossOriginSafe(href);
+    if (!css) {
+      allEmbedded = false;
+      continue;
+    }
+    const inlined = await inlineFontFaceUrls(css, fetchDataUrl);
+    blocks.push(inlined.css);
+    if (!inlined.allEmbedded) {
+      allEmbedded = false;
+    }
+  }
+  return { css: blocks.join("\n\n"), allEmbedded };
+}
+async function fetchAsDataUrl(url) {
+  try {
+    const response = await fetch(url, { mode: url.startsWith("blob:") ? "same-origin" : "cors" });
+    if (!response.ok) {
+      return null;
+    }
+    const blob = await response.blob();
+    return await new Promise((resolve2, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => resolve2(reader.result);
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  } catch {
+    return null;
+  }
+}
+function extractCssUrl(value) {
+  const match = /url\(\s*["']?([^"')]+)["']?\s*\)/u.exec(value);
+  return match ? match[1] : null;
+}
+function needsEmbedding(url) {
+  return url.startsWith("blob:") || url.startsWith("http:") || url.startsWith("https:");
+}
+async function runImgTask(img, src) {
+  const dataUrl = await fetchAsDataUrl(src);
+  if (!dataUrl) {
+    return false;
+  }
+  img.setAttribute("src", dataUrl);
+  return true;
+}
+async function runSvgImageTask(svgImg, href) {
+  const dataUrl = await fetchAsDataUrl(href);
+  if (!dataUrl) {
+    return false;
+  }
+  svgImg.setAttribute("href", dataUrl);
+  svgImg.removeAttribute("xlink:href");
+  return true;
+}
+async function runBackgroundTask(el, bg, url) {
+  const dataUrl = await fetchAsDataUrl(url);
+  if (!dataUrl) {
+    return false;
+  }
+  el.style.backgroundImage = bg.replace(url, dataUrl);
+  return true;
+}
+async function embedImagesOnClone(root) {
+  const tasks = [];
+  for (const img of root.querySelectorAll("img")) {
+    const src = img.getAttribute("src") ?? "";
+    if (needsEmbedding(src)) {
+      tasks.push(() => runImgTask(img, src));
+    }
+  }
+  for (const svgImg of root.querySelectorAll("image")) {
+    const href = svgImg.getAttribute("href") ?? svgImg.getAttribute("xlink:href") ?? "";
+    if (needsEmbedding(href)) {
+      tasks.push(() => runSvgImageTask(svgImg, href));
+    }
+  }
+  const withBackground = [root, ...Array.from(root.querySelectorAll("*"))];
+  for (const el of withBackground) {
+    const bg = el.style.backgroundImage;
+    if (!bg || bg === "none") {
+      continue;
+    }
+    const url = extractCssUrl(bg);
+    if (url && needsEmbedding(url)) {
+      tasks.push(() => runBackgroundTask(el, bg, url));
+    }
+  }
+  const results = await Promise.all(tasks.map((task) => task()));
+  const unembeddableCount = results.filter((embedded) => !embedded).length;
+  return { allEmbedded: unembeddableCount === 0, unembeddableCount };
+}
+function escapeAttr(value) {
+  return value.replace(/&/gu, "&amp;").replace(/"/gu, "&quot;");
+}
+async function buildForeignObjectSvgBody(element, doc, options) {
+  const {
+    width,
+    height,
+    backgroundColor,
+    readComputedStyle = (el) => window.getComputedStyle(el)
+  } = options;
+  const clone3 = element.cloneNode(true);
+  inlineComputedStylesOnClone(element, clone3, readComputedStyle);
+  const [{ allEmbedded: imagesEmbedded }, externalFonts] = await Promise.all([
+    embedImagesOnClone(clone3),
+    collectExternalFontFaceCss(doc, fetchAsDataUrl)
+  ]);
+  const allEmbedded = imagesEmbedded && externalFonts.allEmbedded;
+  const fontFaceCss = [collectFontFaceCss(doc), externalFonts.css].filter(Boolean).join("\n\n");
+  const defs = fontFaceCss ? `<defs><style type="text/css"><![CDATA[${fontFaceCss}]]></style></defs>` : "";
+  const bgRect = backgroundColor ? `<rect width="${width}" height="${height}" fill="${escapeAttr(backgroundColor)}" />` : "";
+  const bodyMarkup = [
+    defs,
+    bgRect,
+    `<foreignObject x="0" y="0" width="${width}" height="${height}">`,
+    `<div xmlns="http://www.w3.org/1999/xhtml" style="width:${width}px;height:${height}px;overflow:hidden;">`,
+    clone3.outerHTML,
+    "</div>",
+    "</foreignObject>"
+  ].join("");
+  return { bodyMarkup, allEmbedded, naturalWidth: width, naturalHeight: height };
+}
+function wrapForeignObjectSvg(bodyMarkup, tile) {
+  const { viewBoxX, viewBoxY, viewBoxWidth, viewBoxHeight, outputWidth, outputHeight } = tile;
+  return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${outputWidth}" height="${outputHeight}" viewBox="${viewBoxX} ${viewBoxY} ${viewBoxWidth} ${viewBoxHeight}">${bodyMarkup}</svg>`;
+}
 var FALLBACK_DOWNLOAD_NAME = "presentation.pptx";
 var REVOKE_DELAY_MS = 200;
 var OPEN_REVOKE_DELAY_MS = 6e4;
@@ -195905,11 +198410,11 @@ function lzwEncode(indexed, minCodeSize) {
   let codeSize = minCodeSize + 1;
   let nextCode = eoiCode + 1;
   const maxTableSize = 4096;
-  const table = /* @__PURE__ */ new Map();
+  const table2 = /* @__PURE__ */ new Map();
   const initTable = () => {
-    table.clear();
+    table2.clear();
     for (let i2 = 0; i2 < clearCode; i2++) {
-      table.set(String(i2), i2);
+      table2.set(String(i2), i2);
     }
     codeSize = minCodeSize + 1;
     nextCode = eoiCode + 1;
@@ -195930,15 +198435,15 @@ function lzwEncode(indexed, minCodeSize) {
   let current = String(indexed[0]);
   for (let i2 = 1; i2 < indexed.length; i2++) {
     const next = `${current},${String(indexed[i2])}`;
-    if (table.has(next)) {
+    if (table2.has(next)) {
       current = next;
     } else {
-      const currentCode = table.get(current);
+      const currentCode = table2.get(current);
       if (currentCode !== void 0) {
         writeBits(currentCode, codeSize);
       }
       if (nextCode < maxTableSize) {
-        table.set(next, nextCode++);
+        table2.set(next, nextCode++);
         if (nextCode > 1 << codeSize && codeSize < 12) {
           codeSize++;
         }
@@ -195949,7 +198454,7 @@ function lzwEncode(indexed, minCodeSize) {
       current = String(indexed[i2]);
     }
   }
-  const finalCode = table.get(current);
+  const finalCode = table2.get(current);
   if (finalCode !== void 0) {
     writeBits(finalCode, codeSize);
   }
@@ -196916,13 +199421,13 @@ async function normalizeColorsForCapture(doc, clonedEl) {
   resolveRootCustomProperties(doc);
   resolveUnsupportedColours(clonedEl);
 }
-function buildSlidesPdfBytes(images) {
-  const PAGE_W = 842;
-  const PAGE_H = 595;
+var PDF_SLIDES_PAGE_WIDTH_PT = 842;
+var PDF_SLIDES_PAGE_HEIGHT_PT = 595;
+function buildTiledSlidesPdfBytes(pages) {
+  const PAGE_W = PDF_SLIDES_PAGE_WIDTH_PT;
+  const PAGE_H = PDF_SLIDES_PAGE_HEIGHT_PT;
   const offsets = [];
   let pos2 = 0;
-  const objCount = 2 + images.length * 3;
-  const pageObjIds = [];
   const segments = [];
   const emitStr = (s) => {
     segments.push(s);
@@ -196938,33 +199443,42 @@ function buildSlidesPdfBytes(images) {
   emitStr("%PDF-1.4\n%\xE2\xE3\xCF\xD3\n");
   markObj();
   emitStr("1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
-  for (let i2 = 0; i2 < images.length; i2++) {
-    const img = images[i2];
-    const imgObjId = 3 + i2 * 3;
-    const pageObjId = 3 + i2 * 3 + 1;
-    const contObjId = 3 + i2 * 3 + 2;
+  let nextObjId = 3;
+  const pageObjIds = [];
+  for (const pageImages of pages) {
+    const imgObjIds = [];
+    for (let i2 = 0; i2 < pageImages.length; i2++) {
+      imgObjIds.push(nextObjId);
+      nextObjId++;
+    }
+    const pageObjId = nextObjId++;
+    const contObjId = nextObjId++;
     pageObjIds.push(pageObjId);
-    const scale2 = Math.min(PAGE_W / img.w, PAGE_H / img.h);
-    const dw = img.w * scale2;
-    const dh = img.h * scale2;
-    const dx = (PAGE_W - dw) / 2;
-    const dy = (PAGE_H - dh) / 2;
-    markObj();
-    const imgHeader = `${imgObjId} 0 obj
-<< /Type /XObject /Subtype /Image /Width ${img.w} /Height ${img.h} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${img.bytes.length} >>
+    for (let idx = 0; idx < pageImages.length; idx++) {
+      markObj();
+      const { image } = pageImages[idx];
+      emitStr(
+        `${imgObjIds[idx]} 0 obj
+<< /Type /XObject /Subtype /Image /Width ${image.w} /Height ${image.h} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${image.bytes.length} >>
 stream
-`;
-    emitStr(imgHeader);
-    emitBin(img.bytes);
-    emitStr("\nendstream\nendobj\n");
+`
+      );
+      emitBin(image.bytes);
+      emitStr("\nendstream\nendobj\n");
+    }
     markObj();
+    const xobjectDict = pageImages.map((_, idx) => `/Img${idx} ${imgObjIds[idx]} 0 R`).join(" ");
     emitStr(
       `${pageObjId} 0 obj
-<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${PAGE_W} ${PAGE_H}] /Contents ${contObjId} 0 R /Resources << /XObject << /Img${i2} ${imgObjId} 0 R >> >> >>
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${PAGE_W} ${PAGE_H}] /Contents ${contObjId} 0 R /Resources << /XObject << ${xobjectDict} >> >> >>
 endobj
 `
     );
-    const contentStream = `q ${dw.toFixed(2)} 0 0 ${dh.toFixed(2)} ${dx.toFixed(2)} ${dy.toFixed(2)} cm /Img${i2} Do Q`;
+    const contentStream = pageImages.map((entry2, idx) => {
+      const { x, y, width, height } = entry2.placement;
+      const rawY = PAGE_H - y - height;
+      return `q ${width.toFixed(2)} 0 0 ${height.toFixed(2)} ${x.toFixed(2)} ${rawY.toFixed(2)} cm /Img${idx} Do Q`;
+    }).join(" ");
     markObj();
     emitStr(
       `${contObjId} 0 obj
@@ -196979,9 +199493,10 @@ endobj
   const pagesKids = pageObjIds.map((id) => `${id} 0 R`).join(" ");
   offsets.splice(1, 0, pos2);
   emitStr(`2 0 obj
-<< /Type /Pages /Kids [${pagesKids}] /Count ${images.length} >>
+<< /Type /Pages /Kids [${pagesKids}] /Count ${pages.length} >>
 endobj
 `);
+  const objCount = nextObjId - 1;
   const xrefPos = pos2;
   const totalObjs = objCount + 1;
   emitStr(`xref
@@ -197435,6 +199950,531 @@ function segmentFrameCount(durationMs, fps) {
   }
   return Math.max(1, Math.ceil(durationMs / (1e3 / fps)));
 }
+var table;
+function getTable() {
+  if (table) {
+    return table;
+  }
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    t[n] = c >>> 0;
+  }
+  table = t;
+  return t;
+}
+function crc322(bytes) {
+  const t = getTable();
+  let crc = 4294967295;
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    crc = t[(crc ^ bytes[i2]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+var PNG_SIGNATURE3 = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+function u32be(value) {
+  return new Uint8Array([
+    value >>> 24 & 255,
+    value >>> 16 & 255,
+    value >>> 8 & 255,
+    value & 255
+  ]);
+}
+function asciiBytes(type) {
+  const out = new Uint8Array(type.length);
+  for (let i2 = 0; i2 < type.length; i2++) {
+    out[i2] = type.charCodeAt(i2);
+  }
+  return out;
+}
+function concatBytes2(parts) {
+  const total = parts.reduce((sum, p) => sum + p.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function buildPngChunk(type, data) {
+  const typeBytes = asciiBytes(type);
+  const crc = crc322(concatBytes2([typeBytes, data]));
+  return concatBytes2([u32be(data.length), typeBytes, data, u32be(crc)]);
+}
+var PNG_COLOR_TYPE_RGBA = 6;
+function buildIhdrChunk(width, height) {
+  const data = new Uint8Array(13);
+  data.set(u32be(width), 0);
+  data.set(u32be(height), 4);
+  data[8] = 8;
+  data[9] = PNG_COLOR_TYPE_RGBA;
+  data[10] = 0;
+  data[11] = 0;
+  data[12] = 0;
+  return buildPngChunk("IHDR", data);
+}
+function buildIendChunk() {
+  return buildPngChunk("IEND", new Uint8Array(0));
+}
+function assemblePng(width, height, idatChunks) {
+  return concatBytes2([
+    PNG_SIGNATURE3,
+    buildIhdrChunk(width, height),
+    ...idatChunks,
+    buildIendChunk()
+  ]);
+}
+function buildIdatChunk(zlibBytes) {
+  return buildPngChunk("IDAT", zlibBytes);
+}
+var RGBA_BYTES_PER_PIXEL = 4;
+function filterPixelBlock(pixels, width, height) {
+  const rowBytes = width * RGBA_BYTES_PER_PIXEL;
+  if (pixels.length !== rowBytes * height) {
+    throw new Error(
+      `filterPixelBlock: expected ${rowBytes * height} bytes for ${width}x${height} RGBA, got ${pixels.length}`
+    );
+  }
+  const out = new Uint8Array((rowBytes + 1) * height);
+  for (let row = 0; row < height; row++) {
+    const srcStart = row * rowBytes;
+    out[row * (rowBytes + 1)] = 0;
+    out.set(pixels.subarray(srcStart, srcStart + rowBytes), row * (rowBytes + 1) + 1);
+  }
+  return out;
+}
+async function concatChunks(parts) {
+  const total = parts.reduce((sum, p) => sum + p.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+async function deflateBlocks(blocks) {
+  const cs = new CompressionStream("deflate");
+  const writer = cs.writable.getWriter();
+  const reader = cs.readable.getReader();
+  const outChunks = [];
+  const readLoop = (async () => {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      outChunks.push(value);
+    }
+  })();
+  for await (const block of blocks) {
+    await writer.write(new Uint8Array(block));
+  }
+  await writer.close();
+  await readLoop;
+  return concatChunks(outChunks);
+}
+async function encodePngFromRowBands(width, height, rowBands) {
+  let coveredRows = 0;
+  async function* filteredBlocks() {
+    for await (const band of rowBands) {
+      coveredRows += band.bandHeight;
+      yield filterPixelBlock(band.pixels, width, band.bandHeight);
+    }
+  }
+  const zlibBytes = await deflateBlocks(filteredBlocks());
+  if (coveredRows !== height) {
+    throw new Error(
+      `encodePngFromRowBands: row-bands covered ${coveredRows} rows, expected ${height}`
+    );
+  }
+  return assemblePng(width, height, [buildIdatChunk(zlibBytes)]);
+}
+var ForeignObjectRasterError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ForeignObjectRasterError";
+  }
+  cause;
+};
+function loadImage(src) {
+  return new Promise((resolve2, reject) => {
+    const img = new Image();
+    img.onload = () => resolve2(img);
+    img.onerror = (event) => reject(new ForeignObjectRasterError("SVG image failed to load", event));
+    img.src = src;
+  });
+}
+var FOREIGN_OBJECT_SVG_DATA_URL_PREFIX = "data:image/svg+xml;charset=utf-8,";
+function foreignObjectSvgToDataUrl(svg) {
+  return `${FOREIGN_OBJECT_SVG_DATA_URL_PREFIX}${encodeURIComponent(svg)}`;
+}
+async function rasterizeForeignObjectSvg(svg, outputWidth, outputHeight, backgroundColor) {
+  const img = await loadImage(foreignObjectSvgToDataUrl(svg));
+  const canvas = document.createElement("canvas");
+  canvas.width = outputWidth;
+  canvas.height = outputHeight;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new ForeignObjectRasterError("2D canvas context unavailable");
+  }
+  if (backgroundColor) {
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, outputWidth, outputHeight);
+  }
+  ctx.drawImage(img, 0, 0, outputWidth, outputHeight);
+  try {
+    ctx.getImageData(0, 0, 1, 1);
+  } catch (cause) {
+    throw new ForeignObjectRasterError(
+      "Canvas tainted by an un-embedded cross-origin resource",
+      cause
+    );
+  }
+  return canvas;
+}
+var CANVAS_DIMENSION_CANDIDATES = [
+  16384,
+  14188,
+  11180,
+  8192,
+  4096,
+  2048
+];
+var MARKER = { r: 17, g: 187, b: 221, a: 255 };
+function canvasReportsMarker(factory, dim) {
+  try {
+    const canvas = factory(dim, 1);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return { ok: false, probeFailed: true };
+    }
+    ctx.fillStyle = `rgba(${MARKER.r},${MARKER.g},${MARKER.b},1)`;
+    ctx.fillRect(dim - 1, 0, 1, 1);
+    const pixel = ctx.getImageData(dim - 1, 0, 1, 1).data;
+    const ok = pixel[0] === MARKER.r && pixel[1] === MARKER.g && pixel[2] === MARKER.b;
+    return { ok, probeFailed: false };
+  } catch {
+    return { ok: false, probeFailed: false };
+  }
+}
+function probeMaxCanvasDimension(factory = (w, h2) => {
+  const el = document.createElement("canvas");
+  el.width = w;
+  el.height = h2;
+  return el;
+}) {
+  for (const dim of CANVAS_DIMENSION_CANDIDATES) {
+    const { ok, probeFailed } = canvasReportsMarker(factory, dim);
+    if (ok) {
+      return dim;
+    }
+    if (probeFailed) {
+      break;
+    }
+  }
+  return CANVAS_DIMENSION_CANDIDATES[CANVAS_DIMENSION_CANDIDATES.length - 1];
+}
+function ensureExactSize(canvas, outputSize) {
+  if (canvas.width === outputSize.width && canvas.height === outputSize.height) {
+    return canvas;
+  }
+  const exact = document.createElement("canvas");
+  exact.width = outputSize.width;
+  exact.height = outputSize.height;
+  const ctx = exact.getContext("2d");
+  if (!ctx) {
+    return canvas;
+  }
+  ctx.drawImage(
+    canvas,
+    0,
+    0,
+    canvas.width,
+    canvas.height,
+    0,
+    0,
+    outputSize.width,
+    outputSize.height
+  );
+  return exact;
+}
+async function rasterizeWindow(body, sourceRect, outputSize, backgroundColor, options) {
+  const { mode = "auto", vectorSvgFallback, html2canvasFallback, onStrategyFailed } = options;
+  if (mode !== "html2canvas" && body && body.allEmbedded) {
+    try {
+      const svg = wrapForeignObjectSvg(body.bodyMarkup, {
+        viewBoxX: sourceRect.x,
+        viewBoxY: sourceRect.y,
+        viewBoxWidth: sourceRect.width,
+        viewBoxHeight: sourceRect.height,
+        outputWidth: outputSize.width,
+        outputHeight: outputSize.height
+      });
+      const canvas2 = await rasterizeForeignObjectSvg(
+        svg,
+        outputSize.width,
+        outputSize.height,
+        backgroundColor
+      );
+      return { canvas: ensureExactSize(canvas2, outputSize), strategy: "foreignObject" };
+    } catch (error) {
+      onStrategyFailed?.(
+        "foreignObject",
+        error instanceof ForeignObjectRasterError ? error : error
+      );
+    }
+  }
+  if (mode !== "html2canvas" && vectorSvgFallback) {
+    try {
+      const canvas2 = await vectorSvgFallback(sourceRect, outputSize);
+      return { canvas: ensureExactSize(canvas2, outputSize), strategy: "vectorSvg" };
+    } catch (error) {
+      onStrategyFailed?.("vectorSvg", error);
+    }
+  }
+  const canvas = await html2canvasFallback(sourceRect, outputSize);
+  return { canvas: ensureExactSize(canvas, outputSize), strategy: "html2canvas" };
+}
+var RASTER_STRATEGY_FALLBACK_WARNING = "[pptx-viewer] raster export:";
+function warnStrategyFailed(strategy, error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  console.warn(
+    `${RASTER_STRATEGY_FALLBACK_WARNING} ${strategy} strategy failed, falling back to the next one (${detail})`
+  );
+}
+async function rasterizeElementTiles(element, naturalWidth, naturalHeight, doc, options) {
+  const scale2 = options.scale && options.scale > 0 ? options.scale : 1;
+  const maxDim = options.maxCanvasDim ?? probeMaxCanvasDimension();
+  const plan = computeExportTilePlan(naturalWidth * scale2, naturalHeight * scale2, maxDim);
+  const body = options.mode === "html2canvas" ? void 0 : await buildForeignObjectSvgBody(
+    element,
+    doc,
+    {
+      width: naturalWidth,
+      height: naturalHeight,
+      backgroundColor: options.backgroundColor
+    }
+  );
+  const strategyOptions = {
+    mode: options.mode,
+    vectorSvgFallback: options.vectorSvgFallback,
+    html2canvasFallback: options.html2canvasFallback,
+    onStrategyFailed: options.onStrategyFailed ?? warnStrategyFailed
+  };
+  const tiles = [];
+  let done = 0;
+  for (const tile of plan.tiles) {
+    const { canvas, strategy } = await rasterizeWindow(
+      body,
+      tileRectToSourceRect(tile, scale2),
+      { width: tile.width, height: tile.height },
+      options.backgroundColor,
+      strategyOptions
+    );
+    tiles.push({
+      col: tile.col,
+      row: tile.row,
+      x: tile.x,
+      y: tile.y,
+      width: tile.width,
+      height: tile.height,
+      canvas,
+      strategy
+    });
+    done++;
+    options.onTileProgress?.(done, plan.tiles.length);
+  }
+  return { fullWidth: plan.fullWidth, fullHeight: plan.fullHeight, tiled: plan.tiled, tiles };
+}
+function combineTileRowPixels(tiles, fullWidth) {
+  if (tiles.length === 0) {
+    throw new Error("combineTileRowPixels: at least one tile is required");
+  }
+  const bandHeight = tiles[0].height;
+  const totalWidth = tiles.reduce((sum, t) => sum + t.width, 0);
+  if (totalWidth !== fullWidth) {
+    throw new Error(
+      `combineTileRowPixels: tile widths sum to ${totalWidth}, expected ${fullWidth}`
+    );
+  }
+  for (const tile of tiles) {
+    if (tile.height !== bandHeight) {
+      throw new Error("combineTileRowPixels: every tile in a row must share the same height");
+    }
+  }
+  const out = new Uint8Array(fullWidth * 4 * bandHeight);
+  for (let y = 0; y < bandHeight; y++) {
+    let xOffset = 0;
+    for (const tile of tiles) {
+      const rowBytes = tile.width * 4;
+      const srcStart = y * rowBytes;
+      const destStart = y * fullWidth * 4 + xOffset * 4;
+      out.set(tile.pixels.subarray(srcStart, srcStart + rowBytes), destStart);
+      xOffset += tile.width;
+    }
+  }
+  return out;
+}
+function groupTilesByRow(tiles) {
+  const rowCount = tiles.reduce((max, t) => Math.max(max, t.row), 0) + 1;
+  const rows = Array.from({ length: rowCount }, () => []);
+  for (const tile of tiles) {
+    rows[tile.row][tile.col] = tile;
+  }
+  return rows;
+}
+async function stitchTilesToPng(fullWidth, fullHeight, tiles) {
+  const rows = groupTilesByRow(tiles);
+  async function* rowBands() {
+    for (const rowTiles of rows) {
+      const pixelTiles = rowTiles.map((tile) => {
+        const ctx = tile.canvas.getContext("2d");
+        if (!ctx) {
+          throw new Error("rasterizeElement: 2D canvas context unavailable while stitching tiles");
+        }
+        return {
+          pixels: ctx.getImageData(0, 0, tile.canvas.width, tile.canvas.height).data,
+          width: tile.canvas.width,
+          height: tile.canvas.height
+        };
+      });
+      yield {
+        pixels: combineTileRowPixels(pixelTiles, fullWidth),
+        bandHeight: pixelTiles[0].height
+      };
+    }
+  }
+  return encodePngFromRowBands(fullWidth, fullHeight, rowBands());
+}
+async function rasterizeElement(element, naturalWidth, naturalHeight, doc, options) {
+  const { fullWidth, fullHeight, tiled, tiles } = await rasterizeElementTiles(
+    element,
+    naturalWidth,
+    naturalHeight,
+    doc,
+    options
+  );
+  if (!tiled) {
+    const only = tiles[0];
+    return {
+      kind: "canvas",
+      canvas: only.canvas,
+      strategy: only.strategy,
+      width: only.width,
+      height: only.height
+    };
+  }
+  const bytes = await stitchTilesToPng(fullWidth, fullHeight, tiles);
+  return {
+    kind: "png-bytes",
+    bytes,
+    width: fullWidth,
+    height: fullHeight,
+    strategies: tiles.map((t) => t.strategy)
+  };
+}
+function placeTileOnPage(tile, fullWidth, fullHeight, pageWidth, pageHeight) {
+  const fitScale = fullWidth > 0 && fullHeight > 0 ? Math.min(pageWidth / fullWidth, pageHeight / fullHeight) : 0;
+  const fittedWidth = fullWidth * fitScale;
+  const fittedHeight = fullHeight * fitScale;
+  const offsetX = (pageWidth - fittedWidth) / 2;
+  const offsetY = (pageHeight - fittedHeight) / 2;
+  return {
+    x: offsetX + tile.x * fitScale,
+    y: offsetY + tile.y * fitScale,
+    width: tile.width * fitScale,
+    height: tile.height * fitScale
+  };
+}
+var CANVAS_DIMENSION_CANDIDATES2 = [
+  16384,
+  14188,
+  11180,
+  8192,
+  4096,
+  2048
+];
+var MARKER2 = { r: 17, g: 187, b: 221, a: 255 };
+function canvasReportsMarker2(factory, dim) {
+  try {
+    const canvas = factory(dim, 1);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return { ok: false, probeFailed: true };
+    }
+    ctx.fillStyle = `rgba(${MARKER2.r},${MARKER2.g},${MARKER2.b},1)`;
+    ctx.fillRect(dim - 1, 0, 1, 1);
+    const pixel = ctx.getImageData(dim - 1, 0, 1, 1).data;
+    const ok = pixel[0] === MARKER2.r && pixel[1] === MARKER2.g && pixel[2] === MARKER2.b;
+    return { ok, probeFailed: false };
+  } catch {
+    return { ok: false, probeFailed: false };
+  }
+}
+function probeMaxCanvasDimension2(factory = (w, h2) => {
+  const el = document.createElement("canvas");
+  el.width = w;
+  el.height = h2;
+  return el;
+}) {
+  for (const dim of CANVAS_DIMENSION_CANDIDATES2) {
+    const { ok, probeFailed } = canvasReportsMarker2(factory, dim);
+    if (ok) {
+      return dim;
+    }
+    if (probeFailed) {
+      break;
+    }
+  }
+  return CANVAS_DIMENSION_CANDIDATES2[CANVAS_DIMENSION_CANDIDATES2.length - 1];
+}
+var cachedMaxDim2;
+function getMaxCanvasDimension2(factory) {
+  if (cachedMaxDim2 === void 0) {
+    cachedMaxDim2 = probeMaxCanvasDimension2(factory);
+  }
+  return cachedMaxDim2;
+}
+async function rasterizeElementClampedToCanvas(element, naturalWidth, naturalHeight, doc, options) {
+  const requestedScale = options.scale && options.scale > 0 ? options.scale : 1;
+  const maxDim = options.maxCanvasDim ?? getMaxCanvasDimension2();
+  const fullWidth = naturalWidth * requestedScale;
+  const fullHeight = naturalHeight * requestedScale;
+  const largestEdge = Math.max(fullWidth, fullHeight);
+  const clampFactor = largestEdge > maxDim ? maxDim / largestEdge : 1;
+  const effectiveScale = requestedScale * clampFactor;
+  const result = await rasterizeElement(element, naturalWidth, naturalHeight, doc, {
+    ...options,
+    scale: effectiveScale,
+    maxCanvasDim: maxDim
+  });
+  if (result.kind !== "canvas") {
+    throw new Error(
+      "rasterizeElementClampedToCanvas: rasterizeElement still tiled after clamping the scale"
+    );
+  }
+  return { ...result, clamped: clampFactor < 1, effectiveScale };
+}
+async function rasterResultToPngBlob(result) {
+  if (result.kind === "png-bytes") {
+    return new Blob([result.bytes.slice()], { type: "image/png" });
+  }
+  return new Promise((resolve2, reject) => {
+    result.canvas.toBlob((blob) => {
+      if (blob) {
+        resolve2(blob);
+      } else {
+        reject(new Error("Canvas toBlob returned null"));
+      }
+    }, "image/png");
+  });
+}
 // `@preserve` (CT_SlideMaster, ECMA-376 §19.3.1.38): mirrors the
 /**
  * @fileoverview Save-side writer for slide-master parts (`p:sldMaster`).
@@ -197573,6 +200613,8 @@ exports.OUTLINE_SLIDE_ATTR = OUTLINE_SLIDE_ATTR;
 exports.OUTLINE_VIEW_ATTR = OUTLINE_VIEW_ATTR;
 exports.PATTERN_OPTIONS = PATTERN_OPTIONS;
 exports.PATTERN_PRESET_OPTIONS = PATTERN_PRESET_OPTIONS;
+exports.PDF_SLIDES_PAGE_HEIGHT_PT = PDF_SLIDES_PAGE_HEIGHT_PT;
+exports.PDF_SLIDES_PAGE_WIDTH_PT = PDF_SLIDES_PAGE_WIDTH_PT;
 exports.PEN_COLORS = PEN_COLORS;
 exports.PPTX_OPEN_ACCEPT = PPTX_OPEN_ACCEPT;
 exports.PRESENTATION_CHANNEL_NAME = PRESENTATION_CHANNEL_NAME;
@@ -197771,7 +200813,6 @@ exports.buildSaveSlides = buildSaveSlides;
 exports.buildSlideTemplateContent = buildSlideTemplateContent;
 exports.buildSlideTemplateSlide = buildSlideTemplateSlide;
 exports.buildSlidesHtml = buildSlidesHtml;
-exports.buildSlidesPdfBytes = buildSlidesPdfBytes;
 exports.buildSmartArt3DModel = buildSmartArt3DModel;
 exports.buildSmartArtA11y = buildSmartArtA11y;
 exports.buildSmartArtPresetData = buildSmartArtPresetData;
@@ -197793,6 +200834,7 @@ exports.buildTextStyleOverrideCss = buildTextStyleOverrideCss;
 exports.buildThemeColorGrid = buildThemeColorGrid;
 exports.buildThemeColorMap = buildThemeColorMap;
 exports.buildThemeColorSwatchGrid = buildThemeColorSwatchGrid;
+exports.buildTiledSlidesPdfBytes = buildTiledSlidesPdfBytes;
 exports.buildUserFontFaceStyles = buildUserFontFaceStyles;
 exports.canAddTopLevelNode = canAddTopLevelNode;
 exports.canCommitActionType = canCommitActionType;
@@ -198182,6 +201224,7 @@ exports.pickSupportedMimeType = pickSupportedMimeType;
 exports.pieceLetterSpacing = pieceLetterSpacing;
 exports.placeAudienceWindow = placeAudienceWindow;
 exports.placeCaretAtEnd = placeCaretAtEnd;
+exports.placeTileOnPage = placeTileOnPage;
 exports.placeholderPromptDescriptor = placeholderPromptDescriptor;
 exports.playFeedbackSound = playFeedbackSound;
 exports.playGroup = playGroup;
@@ -198208,6 +201251,10 @@ exports.publishLiveInlineText = publishLiveInlineText;
 exports.pushRecentColor = pushRecentColor;
 exports.quickStyleSwatchCss = quickStyleSwatchCss;
 exports.radarStylePatch = radarStylePatch;
+exports.rasterResultToPngBlob = rasterResultToPngBlob;
+exports.rasterizeElement = rasterizeElement;
+exports.rasterizeElementClampedToCanvas = rasterizeElementClampedToCanvas;
+exports.rasterizeElementTiles = rasterizeElementTiles;
 exports.reResolveElementColors = reResolveElementColors;
 exports.reResolveSlideColors = reResolveSlideColors;
 exports.readBackstageRecentFile = readBackstageRecentFile;