@bendyline/squisq-formats 1.4.2 → 2.0.1

package/dist/chunk-VSYHZECT.js

@@ -0,0 +1,778 @@
+import {
+  attrNS,
+  baseDirOf,
+  findRelByType,
+  resolveTarget
+} from "./chunk-YRT7GQ5Y.js";
+import {
+  CONTENT_TYPE_PPTX_SLIDE_LAYOUT,
+  NS_DRAWINGML,
+  NS_PML,
+  NS_R,
+  REL_SLIDE_LAYOUT,
+  REL_SLIDE_MASTER,
+  getPartRelationships,
+  getPartXml,
+  openPackage,
+  throwIfOoxmlAborted
+} from "./chunk-WC7WULGV.js";
+
+// src/pptx/layouts.ts
+var DEFAULT_SLIDE_SIZE = { cx: 12192e3, cy: 6858e3 };
+var CHROME_PH_TYPES = /* @__PURE__ */ new Set(["dt", "ftr", "sldNum", "hdr"]);
+var MAX_INFERRED_TEMPLATES = 12;
+var MAX_DECORATIONS = 4;
+var CANCELLATION_CHECKPOINT_INTERVAL = 128;
+var MIN_DECORATION_AREA_PCT = 2;
+var DEFAULT_TITLE_RECT = { x: 5, y: 4, w: 90, h: 16.7 };
+var DEFAULT_BODY_RECT = { x: 5, y: 23.3, w: 90, h: 66 };
+var DEFAULT_TITLE_PT = 44;
+var DEFAULT_SUBTITLE_PT = 24;
+var DEFAULT_BODY_PT = 22;
+async function cancellationCheckpoint(index, signal) {
+  throwIfOoxmlAborted(signal);
+  if (index > 0 && index % CANCELLATION_CHECKPOINT_INTERVAL === 0) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    throwIfOoxmlAborted(signal);
+  }
+}
+function firstPml(parent, local) {
+  const els = parent.getElementsByTagNameNS(NS_PML, local);
+  return els.length > 0 ? els[0] : null;
+}
+function firstDml(parent, local) {
+  const els = parent.getElementsByTagNameNS(NS_DRAWINGML, local);
+  return els.length > 0 ? els[0] : null;
+}
+function intAttr(el, name) {
+  const raw = el?.getAttribute(name);
+  if (!raw) return void 0;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+function pct(value, total) {
+  const raw = value / total * 100;
+  const clamped = Math.max(-10, Math.min(110, raw));
+  return Math.round(clamped * 100) / 100;
+}
+function emuToPct(rect, sldSz) {
+  return {
+    x: pct(rect.x, sldSz.cx),
+    y: pct(rect.y, sldSz.cy),
+    w: pct(rect.cx, sldSz.cx),
+    h: pct(rect.cy, sldSz.cy)
+  };
+}
+function readXfrm(sp) {
+  const spPr = firstPml(sp, "spPr");
+  if (!spPr) return null;
+  const xfrm = firstDml(spPr, "xfrm");
+  if (!xfrm) return null;
+  const off = firstDml(xfrm, "off");
+  const ext = firstDml(xfrm, "ext");
+  const x = intAttr(off, "x");
+  const y = intAttr(off, "y");
+  const cx = intAttr(ext, "cx");
+  const cy = intAttr(ext, "cy");
+  if (x === void 0 || y === void 0 || cx === void 0 || cy === void 0) return null;
+  if (cx <= 0 || cy <= 0) return null;
+  return { x, y, cx, cy };
+}
+function placeholderKind(rawType) {
+  switch (rawType) {
+    case "title":
+    case "ctrTitle":
+      return "title";
+    case "subTitle":
+      return "subtitle";
+    case "":
+    case "body":
+    case "obj":
+      return "text";
+    case "pic":
+    case "clipArt":
+    case "media":
+      return "picture";
+    case "tbl":
+      return "table";
+    case "chart":
+    case "dgm":
+      return "chart";
+    default:
+      return "other";
+  }
+}
+function basePhType(rawType) {
+  switch (rawType) {
+    case "ctrTitle":
+      return "title";
+    case "":
+    case "subTitle":
+    case "obj":
+    case "pic":
+    case "clipArt":
+    case "media":
+    case "tbl":
+    case "chart":
+    case "dgm":
+      return "body";
+    default:
+      return rawType;
+  }
+}
+function parseLvl1Style(container) {
+  const lvl1 = firstDml(container, "lvl1pPr");
+  if (!lvl1) return void 0;
+  const style = {};
+  const algn = lvl1.getAttribute("algn");
+  if (algn === "ctr") style.align = "center";
+  else if (algn === "r") style.align = "right";
+  else if (algn === "l") style.align = "left";
+  const defRPr = firstDml(lvl1, "defRPr");
+  const sz = intAttr(defRPr, "sz");
+  if (sz !== void 0 && sz > 0) style.fontSizePt = sz / 100;
+  const b = defRPr?.getAttribute("b");
+  if (b === "1" || b === "true") style.bold = true;
+  else if (b === "0" || b === "false") style.bold = false;
+  return Object.keys(style).length > 0 ? style : void 0;
+}
+function mergeTextStyle(primary, fallback) {
+  if (!primary) return fallback;
+  if (!fallback) return primary;
+  return {
+    fontSizePt: primary.fontSizePt ?? fallback.fontSizePt,
+    bold: primary.bold ?? fallback.bold,
+    align: primary.align ?? fallback.align,
+    anchor: primary.anchor ?? fallback.anchor
+  };
+}
+async function readMasterIndex(pkg, masterPath, signal) {
+  throwIfOoxmlAborted(signal);
+  const index = { name: "", exact: /* @__PURE__ */ new Map(), baseIdx: /* @__PURE__ */ new Map(), base: /* @__PURE__ */ new Map() };
+  const doc = await getPartXml(pkg, masterPath);
+  if (!doc) return index;
+  index.name = firstPml(doc, "cSld")?.getAttribute("name")?.trim() ?? "";
+  const txStyles = firstPml(doc, "txStyles");
+  if (txStyles) {
+    const titleStyle = firstPml(txStyles, "titleStyle");
+    const bodyStyle = firstPml(txStyles, "bodyStyle");
+    if (titleStyle) index.titleStyle = parseLvl1Style(titleStyle);
+    if (bodyStyle) index.bodyStyle = parseLvl1Style(bodyStyle);
+  }
+  const shapes = doc.getElementsByTagNameNS(NS_PML, "sp");
+  for (let i = 0; i < shapes.length; i++) {
+    await cancellationCheckpoint(i, signal);
+    const sp = shapes[i];
+    const ph = firstPml(sp, "ph");
+    if (!ph) continue;
+    const rawType = ph.getAttribute("type") ?? "";
+    const idx = intAttr(ph, "idx") ?? 0;
+    const entry = { rect: readXfrm(sp) };
+    const txBody = firstPml(sp, "txBody");
+    const lstStyle = txBody ? firstDml(txBody, "lstStyle") : null;
+    if (lstStyle) entry.style = parseLvl1Style(lstStyle);
+    const typeKey = `${rawType || "body"}:${idx}`;
+    if (!index.exact.has(typeKey)) index.exact.set(typeKey, entry);
+    const base = basePhType(rawType);
+    const baseIdxKey = `${base}:${idx}`;
+    if (!index.baseIdx.has(baseIdxKey)) index.baseIdx.set(baseIdxKey, entry);
+    if (!index.base.has(base)) index.base.set(base, entry);
+  }
+  return index;
+}
+function resolveFillColor(solidFill, hints) {
+  const srgb = firstDml(solidFill, "srgbClr");
+  const srgbVal = srgb?.getAttribute("val");
+  if (srgbVal && /^[0-9a-fA-F]{6}$/.test(srgbVal)) return `#${srgbVal.toLowerCase()}`;
+  const scheme = firstDml(solidFill, "schemeClr");
+  const schemeVal = scheme?.getAttribute("val");
+  if (schemeVal && hints.schemeColors?.[schemeVal]) return hints.schemeColors[schemeVal];
+  return void 0;
+}
+function directDmlChild(parent, local) {
+  for (let i = 0; i < parent.childNodes.length; i++) {
+    const child = parent.childNodes[i];
+    if (child && child.nodeType === 1 && child.localName === local) {
+      const el = child;
+      if (el.namespaceURI === NS_DRAWINGML) return el;
+    }
+  }
+  return null;
+}
+function extractDecoration(sp, sldSz, pxPerPt, hints) {
+  const rectEmu = readXfrm(sp);
+  if (!rectEmu) return null;
+  const spPr = firstPml(sp, "spPr");
+  if (!spPr) return null;
+  const prst = firstDml(spPr, "prstGeom")?.getAttribute("prst");
+  if (prst === "line" || prst === "straightConnector1") {
+    const ln = directDmlChild(spPr, "ln");
+    const lnFill = ln ? directDmlChild(ln, "solidFill") : null;
+    const stroke = lnFill ? resolveFillColor(lnFill, hints) : void 0;
+    if (!stroke) return null;
+    const wEmu = intAttr(ln, "w");
+    const strokeWidthPx = wEmu ? Math.max(1, Math.min(40, Math.round(wEmu / 12700 * pxPerPt))) : 2;
+    return { shape: "line", rect: emuToPct(rectEmu, sldSz), stroke, strokeWidthPx };
+  }
+  if (prst === "rect" || prst === "roundRect") {
+    const solidFill = directDmlChild(spPr, "solidFill");
+    const fill = solidFill ? resolveFillColor(solidFill, hints) : void 0;
+    if (!fill) return null;
+    const areaPct = rectEmu.cx * rectEmu.cy / (sldSz.cx * sldSz.cy) * 100;
+    if (areaPct < MIN_DECORATION_AREA_PCT) return null;
+    return {
+      shape: "rect",
+      rect: emuToPct(rectEmu, sldSz),
+      fill,
+      ...prst === "roundRect" ? { borderRadius: 8 } : {}
+    };
+  }
+  return null;
+}
+async function extractLayout(pkg, layoutPath, sldSz, pxPerPt, hints, masterCache, signal) {
+  throwIfOoxmlAborted(signal);
+  const doc = await getPartXml(pkg, layoutPath);
+  if (!doc) return null;
+  const name = firstPml(doc, "cSld")?.getAttribute("name")?.trim() ?? "";
+  const typeAttr = doc.documentElement?.getAttribute("type") ?? void 0;
+  let masterPath;
+  let master;
+  const layoutRels = await getPartRelationships(pkg, layoutPath);
+  const masterRel = findRelByType(layoutRels, REL_SLIDE_MASTER);
+  if (masterRel) {
+    masterPath = resolveTarget(baseDirOf(layoutPath), masterRel.target);
+    let cached = masterCache.get(masterPath);
+    if (!cached) {
+      cached = readMasterIndex(pkg, masterPath, signal);
+      masterCache.set(masterPath, cached);
+    }
+    master = await cached;
+  }
+  const placeholders = [];
+  const decorations = [];
+  const shapes = doc.getElementsByTagNameNS(NS_PML, "sp");
+  for (let i = 0; i < shapes.length; i++) {
+    await cancellationCheckpoint(i, signal);
+    const sp = shapes[i];
+    const ph = firstPml(sp, "ph");
+    if (!ph) {
+      if (decorations.length < MAX_DECORATIONS) {
+        const decoration = extractDecoration(sp, sldSz, pxPerPt, hints);
+        if (decoration) decorations.push(decoration);
+      }
+      continue;
+    }
+    const rawType = ph.getAttribute("type") ?? "";
+    if (CHROME_PH_TYPES.has(rawType)) continue;
+    const idx = intAttr(ph, "idx") ?? 0;
+    const kind = placeholderKind(rawType);
+    const own = readXfrm(sp);
+    let rectEmu = own;
+    let inheritedFromMaster = false;
+    if (!rectEmu && master) {
+      const base = basePhType(rawType);
+      const entry = master.exact.get(`${rawType || "body"}:${idx}`) ?? master.baseIdx.get(`${base}:${idx}`) ?? master.base.get(base);
+      if (entry?.rect) {
+        rectEmu = entry.rect;
+        inheritedFromMaster = true;
+      }
+    }
+    const rect = rectEmu ? emuToPct(rectEmu, sldSz) : kind === "title" ? { ...DEFAULT_TITLE_RECT } : { ...DEFAULT_BODY_RECT };
+    const txBody = firstPml(sp, "txBody");
+    const lstStyle = txBody ? firstDml(txBody, "lstStyle") : null;
+    let textStyle = lstStyle ? parseLvl1Style(lstStyle) : void 0;
+    if (master) {
+      const base = basePhType(rawType);
+      const masterEntry = master.exact.get(`${rawType || "body"}:${idx}`) ?? master.baseIdx.get(`${base}:${idx}`);
+      textStyle = mergeTextStyle(textStyle, masterEntry?.style);
+      textStyle = mergeTextStyle(
+        textStyle,
+        kind === "title" || kind === "subtitle" ? master.titleStyle : master.bodyStyle
+      );
+    }
+    const bodyPr = txBody ? firstDml(txBody, "bodyPr") : null;
+    const anchor = bodyPr?.getAttribute("anchor");
+    if (anchor === "t" || anchor === "ctr" || anchor === "b") {
+      textStyle = {
+        ...textStyle ?? {},
+        anchor: anchor === "t" ? "top" : anchor === "ctr" ? "middle" : "bottom"
+      };
+    }
+    const orient = ph.getAttribute("orient");
+    const vert = bodyPr?.getAttribute("vert");
+    const vertical = orient === "vert" || !!vert && vert !== "horz";
+    placeholders.push({
+      kind,
+      rawType,
+      idx,
+      rect,
+      inheritedFromMaster,
+      vertical,
+      ...textStyle ? { textStyle } : {}
+    });
+  }
+  return {
+    partPath: layoutPath,
+    name,
+    ...typeAttr ? { typeAttr } : {},
+    ...masterPath ? { masterPath } : {},
+    ...master?.name ? { masterName: master.name } : {},
+    placeholders,
+    decorations,
+    slideCount: 0
+  };
+}
+function overlap1D(aStart, aLen, bStart, bLen) {
+  return Math.max(0, Math.min(aStart + aLen, bStart + bLen) - Math.max(aStart, bStart));
+}
+function sideBySide(a, b) {
+  const xOverlap = overlap1D(a.x, a.w, b.x, b.w);
+  const yOverlap = overlap1D(a.y, a.h, b.y, b.h);
+  return xOverlap <= 0.15 * Math.min(a.w, b.w) && yOverlap >= 0.5 * Math.min(a.h, b.h) && a.w >= 25 && b.w >= 25;
+}
+function stackedAbove(a, b) {
+  const xOverlap = overlap1D(a.x, a.w, b.x, b.w);
+  const yOverlap = overlap1D(a.y, a.h, b.y, b.h);
+  return yOverlap <= 0.15 * Math.min(a.h, b.h) && xOverlap >= 0.5 * Math.min(a.w, b.w) && a.y < b.y;
+}
+function fullBleed(p) {
+  return p.w >= 85 && p.h >= 80;
+}
+function nearEqualWidth(a, b) {
+  return Math.abs(a.w - b.w) <= 0.15 * Math.max(a.w, b.w);
+}
+function rectsOverlap(a, b) {
+  return overlap1D(a.x, a.w, b.x, b.w) > 2 && overlap1D(a.y, a.h, b.y, b.h) > 2;
+}
+function centerX(r) {
+  return r.x + r.w / 2;
+}
+var PLAIN_LAYOUT_TYPES = /* @__PURE__ */ new Set([
+  "titleOnly",
+  "tx",
+  "obj",
+  "objOnly",
+  "objTx",
+  "txOverObj",
+  "objOverTx",
+  "tbl",
+  "chart",
+  "dgm",
+  "txAndChart",
+  "chartAndTx",
+  "vertTitleAndTxOverChart",
+  "txAndTwoObj",
+  "twoObjAndTx",
+  "twoObjOverTx",
+  "objAndTwoObj",
+  "twoObjAndObj",
+  "fourObj",
+  "vertTx",
+  "vertTitleAndTx",
+  "clipArtAndVertTx"
+]);
+function stage1(typeAttr) {
+  if (!typeAttr || typeAttr === "cust") return null;
+  if (typeAttr === "title")
+    return { kind: "builtin", template: "title", paramSpec: "titleSubtitle" };
+  if (typeAttr === "secHead") return { kind: "builtin", template: "sectionHeader" };
+  if (typeAttr === "blank") return { kind: "skip" };
+  if (PLAIN_LAYOUT_TYPES.has(typeAttr)) return { kind: "plain" };
+  if (typeAttr === "picTx") return { kind: "feature-by-geometry" };
+  if (typeAttr === "clipArtAndTx" || typeAttr === "mediaAndTx") {
+    return { kind: "builtin", template: "leftFeature", paramSpec: "featureImage" };
+  }
+  if (typeAttr === "txAndClipArt" || typeAttr === "txAndMedia") {
+    return { kind: "builtin", template: "rightFeature", paramSpec: "featureImage" };
+  }
+  if (typeAttr === "twoColTx" || typeAttr === "twoObj" || typeAttr === "txAndObj" || typeAttr === "objAndTx") {
+    return { kind: "custom-two-column" };
+  }
+  if (typeAttr === "twoTxTwoObj") return { kind: "comparison" };
+  return null;
+}
+var WELL_KNOWN_NAMES = {
+  "title slide": { kind: "builtin", template: "title", paramSpec: "titleSubtitle" },
+  "section header": { kind: "builtin", template: "sectionHeader" },
+  "two content": { kind: "custom-two-column" },
+  comparison: { kind: "comparison" },
+  "content with caption": { kind: "custom-caption" },
+  "picture with caption": { kind: "feature-by-geometry" },
+  "title and content": { kind: "plain" },
+  "title only": { kind: "plain" },
+  blank: { kind: "skip" },
+  "vertical title and text": { kind: "plain" },
+  "title and vertical text": { kind: "plain" }
+};
+function stage2(name) {
+  return WELL_KNOWN_NAMES[name.trim().toLowerCase()] ?? null;
+}
+function contentPlaceholders(layout) {
+  return layout.placeholders.filter((p) => p.kind !== "title" && p.kind !== "subtitle");
+}
+function stage3(layout) {
+  if (layout.placeholders.some((p) => p.vertical)) return { kind: "plain" };
+  const hasTitle = layout.placeholders.some((p) => p.kind === "title");
+  const content = contentPlaceholders(layout);
+  if (content.length === 0) return hasTitle ? { kind: "plain" } : { kind: "skip" };
+  const texts = content.filter((p) => p.kind === "text");
+  const pictures = content.filter((p) => p.kind === "picture");
+  const others = content.filter((p) => p.kind !== "text" && p.kind !== "picture");
+  if (pictures.length === 0 && others.length === 0) {
+    if (texts.length === 1) return { kind: "plain" };
+    if (texts.length === 2 && sideBySide(texts[0].rect, texts[1].rect)) {
+      return nearEqualWidth(texts[0].rect, texts[1].rect) ? { kind: "custom-two-column" } : { kind: "custom-caption" };
+    }
+    if (texts.length === 4 && findComparisonColumns(texts)) return { kind: "comparison" };
+    return { kind: "plain" };
+  }
+  if (pictures.length === 1 && others.length === 0) {
+    if (texts.length === 0) {
+      return fullBleed(pictures[0].rect) ? { kind: "builtin", template: "imageWithCaption", paramSpec: "featureImage" } : { kind: "custom-generic" };
+    }
+    return { kind: "feature-by-geometry" };
+  }
+  if (pictures.length >= 2 && pictures.length <= 4 && texts.length === 0 && others.length === 0 && pictures.every((a, i) => pictures.every((b, j) => i === j || !rectsOverlap(a.rect, b.rect)))) {
+    return { kind: "builtin", template: "photoGrid", paramSpec: "photoGridGate" };
+  }
+  return { kind: "plain" };
+}
+function findComparisonColumns(texts) {
+  if (texts.length !== 4) return null;
+  const sorted = [...texts].sort((a, b) => centerX(a.rect) - centerX(b.rect));
+  const leftPair = [sorted[0], sorted[1]];
+  const rightPair = [sorted[2], sorted[3]];
+  const columnWidth = (pair) => Math.abs(centerX(pair[0].rect) - centerX(pair[1].rect));
+  if (columnWidth(leftPair) > 10 || columnWidth(rightPair) > 10) return null;
+  if (centerX(rightPair[0].rect) - centerX(leftPair[1].rect) <= 10) return null;
+  const orderColumn = (pair) => {
+    const byY = [...pair].sort((a, b) => a.rect.y - b.rect.y);
+    const header = byY[0];
+    const body = byY[1];
+    if (header.rect.h > 20 || header.rect.y + header.rect.h > body.rect.y + 2) return null;
+    return [header.idx, body.idx];
+  };
+  const left = orderColumn(leftPair);
+  const right = orderColumn(rightPair);
+  return left && right ? { left, right } : null;
+}
+function slugify(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug;
+}
+function pctPosition(rect) {
+  return { x: `${rect.x}%`, y: `${rect.y}%`, width: `${rect.w}%`, height: `${rect.h}%` };
+}
+function fontPx(pt, defaultPt, pxPerPt) {
+  const sizePt = pt && pt > 0 ? pt : defaultPt;
+  return Math.max(16, Math.min(140, Math.round(sizePt * pxPerPt)));
+}
+function textLayerFor(id, ph, text, role, gen) {
+  const defaultPt = role === "title" ? DEFAULT_TITLE_PT : role === "subtitle" ? DEFAULT_SUBTITLE_PT : DEFAULT_BODY_PT;
+  const style = {
+    fontSize: fontPx(ph.textStyle?.fontSizePt, defaultPt, gen.pxPerPt),
+    color: gen.hints.text ?? "#1a1a1a",
+    lineHeight: role === "title" ? 1.15 : 1.4,
+    ...role === "title" ? { fontWeight: ph.textStyle?.bold === false ? "normal" : "bold" } : ph.textStyle?.bold ? { fontWeight: "bold" } : {},
+    ...ph.textStyle?.align ? { textAlign: ph.textStyle.align } : {},
+    ...ph.textStyle?.anchor ? { verticalAlign: ph.textStyle.anchor } : {}
+  };
+  return { id, type: "text", position: pctPosition(ph.rect), content: { text, style } };
+}
+function imageLayerFor(id, ph, imageIndex) {
+  return {
+    id,
+    type: "image",
+    position: pctPosition(ph.rect),
+    content: { src: `{image:${imageIndex}}`, alt: `{image:${imageIndex}}`, fit: "cover" }
+  };
+}
+function decorationLayers(layout) {
+  return layout.decorations.map((d, i) => ({
+    id: `decor-${i + 1}`,
+    type: "shape",
+    position: pctPosition(d.rect),
+    content: d.shape === "line" ? { shape: "line", stroke: d.stroke, strokeWidth: d.strokeWidthPx ?? 2 } : {
+      shape: "rect",
+      fill: d.fill,
+      ...d.borderRadius ? { borderRadius: d.borderRadius } : {}
+    }
+  }));
+}
+function titlePlaceholder(layout) {
+  return layout.placeholders.find((p) => p.kind === "title");
+}
+function defaultTitlePlaceholder() {
+  return {
+    kind: "title",
+    rawType: "title",
+    idx: 0,
+    rect: { ...DEFAULT_TITLE_RECT },
+    inheritedFromMaster: false,
+    vertical: false
+  };
+}
+function buildTwoColumnDef(layout, gen) {
+  const texts = contentPlaceholders(layout).filter((p) => p.kind === "text");
+  let left;
+  let right;
+  const sorted = [...texts].sort((a, b) => a.rect.x - b.rect.x);
+  if (sorted.length >= 2 && sideBySide(sorted[0].rect, sorted[sorted.length - 1].rect)) {
+    left = sorted[0];
+    right = sorted[sorted.length - 1];
+  } else {
+    left = {
+      ...defaultTitlePlaceholder(),
+      kind: "text",
+      rawType: "body",
+      rect: { x: 5, y: 23.3, w: 43, h: 66 }
+    };
+    right = { ...left, rect: { x: 52, y: 23.3, w: 43, h: 66 } };
+  }
+  const gap = Math.max(0, Math.round((right.rect.x - (left.rect.x + left.rect.w)) * 100) / 100);
+  const layers = [...decorationLayers(layout)];
+  const title = titlePlaceholder(layout) ?? defaultTitlePlaceholder();
+  layers.push(textLayerFor("title", title, "{title}", "title", gen));
+  const itemLayer = {
+    ...textLayerFor("column", left, "{item}", "body", gen),
+    // gap is in percentage points because the layer's width is a %-string;
+    // the repeat resolver offsets clones by width + gap in the same unit.
+    repeat: { source: "listItems", direction: "row", gap, max: 2 }
+  };
+  layers.push(itemLayer);
+  return layers;
+}
+function buildCaptionDef(layout, gen) {
+  const texts = contentPlaceholders(layout).filter((p) => p.kind === "text");
+  const byWidth = [...texts].sort((a, b) => b.rect.w - a.rect.w);
+  const wide = byWidth[0];
+  const narrow = byWidth[1];
+  const layers = [...decorationLayers(layout)];
+  const title = titlePlaceholder(layout) ?? defaultTitlePlaceholder();
+  layers.push(textLayerFor("title", title, "{title}", "title", gen));
+  if (wide) layers.push(textLayerFor("body", wide, "{content}", "body", gen));
+  if (narrow) {
+    layers.push(textLayerFor("caption", narrow, "{attr:caption|}", "body", gen));
+  }
+  return layers;
+}
+function buildGenericDef(layout, gen) {
+  const layers = [...decorationLayers(layout)];
+  const title = titlePlaceholder(layout);
+  if (title) layers.push(textLayerFor("title", title, "{title}", "title", gen));
+  const content = contentPlaceholders(layout);
+  const pictures = content.filter((p) => p.kind === "picture").sort((a, b) => a.idx - b.idx || a.rect.y - b.rect.y);
+  pictures.forEach((ph, k) => layers.push(imageLayerFor(`image-${k}`, ph, k)));
+  const texts = content.filter((p) => p.kind === "text");
+  if (texts.length > 0) layers.push(textLayerFor("body", texts[0], "{content}", "body", gen));
+  if (texts.length > 1) {
+    gen.notes.push(
+      `${texts.length - 1} additional text region(s) could not be bound \u2014 the token grammar has no per-region address; full text stays in the markdown body.`
+    );
+  }
+  const dropped = content.filter(
+    (p) => p.kind === "table" || p.kind === "chart" || p.kind === "other"
+  );
+  if (dropped.length > 0) {
+    gen.notes.push(
+      `${dropped.length} table/chart placeholder(s) dropped (content flows as markdown).`
+    );
+  }
+  return layers;
+}
+function hasContentLayer(layers) {
+  return layers.some((l) => l.type === "text" || l.type === "image");
+}
+function resolveFeatureByGeometry(layout) {
+  const content = contentPlaceholders(layout);
+  const pic = content.find((p) => p.kind === "picture");
+  if (!pic) return { kind: "plain" };
+  const texts = content.filter((p) => p.kind === "text");
+  const beside = texts.find((t) => sideBySide(pic.rect, t.rect));
+  if (beside) {
+    const template = centerX(pic.rect) < centerX(beside.rect) ? "leftFeature" : "rightFeature";
+    return { kind: "builtin", template, paramSpec: "featureImage" };
+  }
+  if (texts.some((t) => stackedAbove(pic.rect, t.rect)) || fullBleed(pic.rect)) {
+    return { kind: "builtin", template: "imageWithCaption", paramSpec: "featureImage" };
+  }
+  return { kind: "builtin", template: "leftFeature", paramSpec: "featureImage" };
+}
+function classifyLayout(layout) {
+  return stage1(layout.typeAttr) ?? stage2(layout.name) ?? stage3(layout);
+}
+function resolveVerdict(layout, directive, gen, templateName) {
+  switch (directive.kind) {
+    case "plain":
+    case "skip":
+      return { kind: directive.kind };
+    case "builtin":
+      return directive;
+    case "feature-by-geometry":
+      return resolveFeatureByGeometry(layout);
+    case "comparison": {
+      const texts = contentPlaceholders(layout).filter((p) => p.kind === "text");
+      const columns = findComparisonColumns(texts);
+      if (!columns) return { kind: "plain" };
+      return { kind: "builtin", template: "twoColumn", paramSpec: "comparisonPairs", columns };
+    }
+    case "custom-two-column":
+    case "custom-caption":
+    case "custom-generic":
+    case "by-geometry": {
+      const layers = directive.kind === "custom-two-column" ? buildTwoColumnDef(layout, gen) : directive.kind === "custom-caption" ? buildCaptionDef(layout, gen) : buildGenericDef(layout, gen);
+      if (!hasContentLayer(layers)) return { kind: "plain" };
+      const def = {
+        name: templateName,
+        label: layout.name || "Imported layout",
+        description: `Imported from PowerPoint layout "${layout.name || templateName}"${layout.masterName ? ` (master "${layout.masterName}")` : ""}`,
+        viewport: gen.viewport,
+        layers
+      };
+      return { kind: "custom", def };
+    }
+  }
+}
+async function readSlideSize(pkg, signal) {
+  throwIfOoxmlAborted(signal);
+  const pres = await getPartXml(pkg, "ppt/presentation.xml");
+  const sldSz = pres ? firstPml(pres, "sldSz") : null;
+  const cx = intAttr(sldSz, "cx");
+  const cy = intAttr(sldSz, "cy");
+  if (cx && cy && cx > 0 && cy > 0) return { cx, cy };
+  return { ...DEFAULT_SLIDE_SIZE };
+}
+async function orderedSlidePathsForLayouts(pkg, signal) {
+  throwIfOoxmlAborted(signal);
+  const pres = await getPartXml(pkg, "ppt/presentation.xml");
+  if (!pres) return [];
+  const rels = await getPartRelationships(pkg, "ppt/presentation.xml");
+  const relById = new Map(rels.map((r) => [r.id, r.target]));
+  const out = [];
+  const ids = pres.getElementsByTagNameNS(NS_PML, "sldId");
+  for (let i = 0; i < ids.length; i++) {
+    await cancellationCheckpoint(i, signal);
+    const rid = attrNS(ids[i], NS_R, "id", "r:id");
+    const target = rid ? relById.get(rid) : void 0;
+    if (target) out.push(resolveTarget("ppt", target));
+  }
+  return out;
+}
+function viewportFor(sldSz) {
+  if (sldSz.cy > sldSz.cx) {
+    return { width: 1080, height: Math.round(1080 * sldSz.cy / sldSz.cx) };
+  }
+  return { width: Math.round(1080 * sldSz.cx / sldSz.cy), height: 1080 };
+}
+async function analyzePptxLayouts(pkg, options = {}) {
+  throwIfOoxmlAborted(options.signal);
+  const warnings = [];
+  const hints = options.colors ?? {};
+  const maxTemplates = options.maxTemplates ?? MAX_INFERRED_TEMPLATES;
+  const sldSz = await readSlideSize(pkg, options.signal);
+  const viewport = viewportFor(sldSz);
+  const pxPerPt = viewport.height / (sldSz.cy / 12700);
+  const slidePaths = await orderedSlidePathsForLayouts(pkg, options.signal);
+  const layoutPathBySlide = /* @__PURE__ */ new Map();
+  const usage = /* @__PURE__ */ new Map();
+  const orderedLayoutPaths = [];
+  for (let slideIndex = 0; slideIndex < slidePaths.length; slideIndex++) {
+    await cancellationCheckpoint(slideIndex, options.signal);
+    const slidePath = slidePaths[slideIndex];
+    const rels = await getPartRelationships(pkg, slidePath);
+    const layoutRel = findRelByType(rels, REL_SLIDE_LAYOUT);
+    if (!layoutRel) continue;
+    const layoutPath = resolveTarget(baseDirOf(slidePath), layoutRel.target);
+    layoutPathBySlide.set(slidePath, layoutPath);
+    if (!usage.has(layoutPath)) orderedLayoutPaths.push(layoutPath);
+    usage.set(layoutPath, (usage.get(layoutPath) ?? 0) + 1);
+  }
+  if (options.includeUnused) {
+    const unused = [];
+    let partIndex = 0;
+    for (const [partPath, contentType] of pkg.contentTypes.overrides) {
+      await cancellationCheckpoint(partIndex++, options.signal);
+      if (contentType === CONTENT_TYPE_PPTX_SLIDE_LAYOUT && !usage.has(partPath)) {
+        unused.push(partPath);
+      }
+    }
+    unused.sort();
+    orderedLayoutPaths.push(...unused);
+  }
+  const masterCache = /* @__PURE__ */ new Map();
+  const layouts = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < orderedLayoutPaths.length; i++) {
+    await cancellationCheckpoint(i, options.signal);
+    const layoutPath = orderedLayoutPaths[i];
+    const extracted = await extractLayout(
+      pkg,
+      layoutPath,
+      sldSz,
+      pxPerPt,
+      hints,
+      masterCache,
+      options.signal
+    );
+    if (!extracted) {
+      warnings.push(`layout ${layoutPath} could not be read; its slides import plain`);
+      continue;
+    }
+    extracted.slideCount = usage.get(layoutPath) ?? 0;
+    const baseSlug = slugify(extracted.name) || `layout-${i + 1}`;
+    let templateName = `pptx-${baseSlug}`;
+    for (let n = 2; usedNames.has(templateName); n++) templateName = `pptx-${baseSlug}-${n}`;
+    const notes = [];
+    const gen = { hints, pxPerPt, viewport, notes };
+    const directive = classifyLayout(extracted);
+    const verdict = resolveVerdict(extracted, directive, gen, templateName);
+    if (verdict.kind === "custom") usedNames.add(templateName);
+    layouts.push({ extracted, verdict, notes });
+  }
+  const customs = layouts.filter((l) => l.verdict.kind === "custom");
+  if (customs.length > maxTemplates) {
+    const ranked = [...customs].sort((a, b) => b.extracted.slideCount - a.extracted.slideCount);
+    const excess = ranked.slice(maxTemplates);
+    for (let index = 0; index < excess.length; index++) {
+      await cancellationCheckpoint(index, options.signal);
+      const layout = excess[index];
+      layout.verdict = { kind: "plain" };
+      layout.notes.push("dropped: more inferred layouts than the template cap");
+    }
+    warnings.push(
+      `deck defines ${customs.length} distinctive layouts; kept the ${maxTemplates} most used as custom templates`
+    );
+  }
+  const byLayoutPath = new Map(layouts.map((l) => [l.extracted.partPath, l]));
+  throwIfOoxmlAborted(options.signal);
+  return { slideSize: sldSz, layouts, byLayoutPath, layoutPathBySlide, warnings };
+}
+async function inspectPptxLayouts(data, options = {}) {
+  throwIfOoxmlAborted(options.signal);
+  const pkg = await openPackage(data, options);
+  const analysis = await analyzePptxLayouts(pkg, options);
+  const layouts = [];
+  for (let i = 0; i < analysis.layouts.length; i++) {
+    await cancellationCheckpoint(i, options.signal);
+    const l = analysis.layouts[i];
+    const { extracted, verdict, notes } = l;
+    layouts.push({
+      layoutPath: extracted.partPath,
+      name: extracted.name || `Layout ${i + 1}`,
+      ...extracted.masterName ? { masterName: extracted.masterName } : {},
+      ...extracted.typeAttr ? { typeAttr: extracted.typeAttr } : {},
+      slideCount: extracted.slideCount,
+      verdict: verdict.kind,
+      ...verdict.kind === "builtin" ? { builtinTemplate: verdict.template } : {},
+      ...verdict.kind === "custom" ? { customTemplate: verdict.def } : {},
+      ...notes.length > 0 ? { notes } : {}
+    });
+  }
+  return { layouts, slideSize: analysis.slideSize };
+}
+
+export {
+  analyzePptxLayouts,
+  inspectPptxLayouts
+};
+//# sourceMappingURL=chunk-VSYHZECT.js.map