@bendyline/squisq-formats 2.7.6 → 2.8.1

package/dist/{chunk-JZ33FB6V.js → chunk-QRDJOYT3.js}

@@ -62,11 +62,12 @@ import {
   fontAwesomeGlyph
 } from "./chunk-LBXBRFBZ.js";
 import {
-  extToMime
+  extToMime,
+  readImageDimensions
 } from "./chunk-JZR32FON.js";
 
 // src/pptx/export.ts
-import { resolveFontFamily, VIEWPORT_PRESETS } from "@bendyline/squisq/schemas";
+import { VIEWPORT_PRESETS } from "@bendyline/squisq/schemas";
 import {
   buildPreviewDoc,
   createTemplateContext,
@@ -74,13 +75,14 @@ import {
   expandCoverBlock,
   expandDocBlocks,
   flattenRenderableBlocks,
+  isGeometryBoundTemplate,
   isTemplateBlock,
   resolvePersistentLayers,
   resolveThemeForDoc
 } from "@bendyline/squisq/doc";
-import { splitIconMarkers } from "@bendyline/squisq/icon-marker";
+import { splitIconMarkers as splitIconMarkers3 } from "@bendyline/squisq/icon-marker";
 import {
-  isSvgImageSource,
+  isSvgImageSource as isSvgImageSource2,
   parseVideoEmbedUrl,
   readFrontmatterThemeId
 } from "@bendyline/squisq/markdown";
@@ -179,6 +181,1095 @@ var DEFAULT_TITLE_SIZE = 4400;
 var DEFAULT_CODE_SIZE = 1400;
 var HYPERLINK_COLOR = "0563C1";
 
+// src/pptx/geometry.ts
+var EMU_PER_CANVAS_PX = SLIDE_WIDTH / 1920;
+function resolvePositionValue(value, dimension) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.endsWith("%")) {
+      const percent = Number.parseFloat(trimmed);
+      if (Number.isFinite(percent)) return percent / 100 * dimension;
+    }
+    const numeric = Number.parseFloat(trimmed);
+    if (Number.isFinite(numeric)) return numeric;
+  }
+  return 0;
+}
+function resolveLayerRect(position, defaultWidth, defaultHeight) {
+  const width = Math.max(
+    1,
+    position.width != null ? resolvePositionValue(position.width, 1920) : defaultWidth
+  );
+  const height = Math.max(
+    1,
+    position.height != null ? resolvePositionValue(position.height, 1080) : defaultHeight
+  );
+  let x = resolvePositionValue(position.x, 1920);
+  let y = resolvePositionValue(position.y, 1080);
+  const anchor = position.anchor ?? "top-left";
+  if (anchor === "center") {
+    x -= width / 2;
+    y -= height / 2;
+  } else {
+    if (anchor.endsWith("right")) x -= width;
+    if (anchor.startsWith("bottom")) y -= height;
+  }
+  const clippedX = Math.min(1919, Math.max(0, x));
+  const clippedY = Math.min(1079, Math.max(0, y));
+  const clippedWidth = Math.max(1, Math.min(width - (clippedX - x), 1920 - clippedX));
+  const clippedHeight = Math.max(1, Math.min(height - (clippedY - y), 1080 - clippedY));
+  return { x: clippedX, y: clippedY, width: clippedWidth, height: clippedHeight };
+}
+function toEmuRect(rect) {
+  return {
+    x: Math.round(rect.x / 1920 * SLIDE_WIDTH),
+    y: Math.round(rect.y / 1080 * SLIDE_HEIGHT),
+    width: Math.max(1, Math.round(rect.width / 1920 * SLIDE_WIDTH)),
+    height: Math.max(1, Math.round(rect.height / 1080 * SLIDE_HEIGHT))
+  };
+}
+
+// src/pptx/drawingXml.ts
+import { resolveFontFamily } from "@bendyline/squisq/schemas";
+
+// src/pptx/cssPaint.ts
+function parseCssColor(color, fallback) {
+  if (!color) return { hex: toOoxmlHex(fallback), alpha: 1e5 };
+  const trimmed = color.trim();
+  if (trimmed === "transparent" || trimmed === "none") return { hex: "000000", alpha: 0 };
+  const hexMatch = /^#?([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(trimmed);
+  if (hexMatch) {
+    const raw = hexMatch[1];
+    const expanded = raw.length === 3 ? raw.split("").map((char) => char + char).join("") : raw;
+    const alpha = expanded.length === 8 ? Math.round(Number.parseInt(expanded.slice(6, 8), 16) / 255 * 1e5) : 1e5;
+    return { hex: expanded.slice(0, 6).toUpperCase(), alpha };
+  }
+  const rgbMatch = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)$/i.exec(trimmed);
+  if (rgbMatch) {
+    const channel = (value) => Math.max(0, Math.min(255, Math.round(Number(value)))).toString(16).padStart(2, "0");
+    const alpha = rgbMatch[4] ? Math.round(Math.max(0, Math.min(1, Number(rgbMatch[4]))) * 1e5) : 1e5;
+    return {
+      hex: `${channel(rgbMatch[1])}${channel(rgbMatch[2])}${channel(rgbMatch[3])}`.toUpperCase(),
+      alpha
+    };
+  }
+  const named = {
+    black: "000000",
+    white: "FFFFFF",
+    red: "FF0000",
+    blue: "0000FF",
+    green: "008000",
+    gray: "808080",
+    grey: "808080"
+  };
+  return { hex: named[trimmed.toLowerCase()] ?? toOoxmlHex(fallback), alpha: 1e5 };
+}
+function splitTopLevel(value) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const char of value) {
+    if (char === "(") depth++;
+    if (char === ")") depth--;
+    if (char === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+var SIDE_ANGLES = {
+  top: 0,
+  right: 90,
+  bottom: 180,
+  left: 270,
+  "top right": 45,
+  "right top": 45,
+  "bottom right": 135,
+  "right bottom": 135,
+  "bottom left": 225,
+  "left bottom": 225,
+  "top left": 315,
+  "left top": 315
+};
+function parseAngle(token) {
+  const side = /^to\s+(.+)$/i.exec(token);
+  if (side) return SIDE_ANGLES[side[1].trim().toLowerCase().replace(/\s+/g, " ")] ?? null;
+  const match = /^(-?[\d.]+)(deg|turn|rad|grad)$/i.exec(token);
+  if (!match) return null;
+  const value = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  if (!Number.isFinite(value)) return null;
+  if (unit === "turn") return value * 360;
+  if (unit === "rad") return value * 180 / Math.PI;
+  if (unit === "grad") return value * 0.9;
+  return value;
+}
+var POSITION_KEYWORDS = {
+  left: 0,
+  top: 0,
+  center: 0.5,
+  right: 1,
+  bottom: 1
+};
+function parseRadialCenter(token) {
+  const at = /\bat\s+(.+)$/i.exec(token);
+  if (!at) return { x: 0.5, y: 0.5 };
+  const parts = at[1].trim().toLowerCase().split(/\s+/);
+  const value = (part) => {
+    if (part === void 0) return void 0;
+    if (part in POSITION_KEYWORDS) return POSITION_KEYWORDS[part];
+    const percent = /^(-?[\d.]+)%$/.exec(part);
+    return percent ? Number(percent[1]) / 100 : void 0;
+  };
+  if (parts.length === 1) {
+    const only = parts[0];
+    if (only === "top" || only === "bottom") return { x: 0.5, y: value(only) ?? 0.5 };
+    return { x: value(only) ?? 0.5, y: 0.5 };
+  }
+  const [first, second] = parts;
+  if (first === "top" || first === "bottom" || second === "left" || second === "right") {
+    return { x: value(second) ?? 0.5, y: value(first) ?? 0.5 };
+  }
+  return { x: value(first) ?? 0.5, y: value(second) ?? 0.5 };
+}
+var CSS_COLOR = /^(#[0-9a-f]{3}|#[0-9a-f]{6}|#[0-9a-f]{8}|rgba?\([^)]*\)|transparent|black|white|red|blue|green|gr[ae]y)$/i;
+function parseStop(token) {
+  const positions = [];
+  let rest = token.trim();
+  for (; ; ) {
+    const match = /\s+(-?[\d.]+)%$/.exec(rest);
+    if (!match) break;
+    positions.unshift(Number(match[1]) / 100);
+    rest = rest.slice(0, match.index).trim();
+  }
+  if (!CSS_COLOR.test(rest)) return null;
+  const color = parseCssColor(rest, "000000");
+  if (positions.length === 0) return [{ color }];
+  return positions.slice(0, 2).map((position) => ({ color: { ...color }, position }));
+}
+function resolveStopPositions(raw) {
+  const positions = raw.map((stop) => stop.position);
+  if (positions[0] === void 0) positions[0] = 0;
+  if (positions[positions.length - 1] === void 0) positions[positions.length - 1] = 1;
+  let previous = 0;
+  for (let index = 0; index < positions.length; index++) {
+    const value = positions[index];
+    if (value === void 0) continue;
+    positions[index] = Math.max(previous, value);
+    previous = positions[index];
+  }
+  for (let index = 1; index < positions.length; index++) {
+    if (positions[index] !== void 0) continue;
+    const start = index - 1;
+    let end = index;
+    while (positions[end] === void 0) end++;
+    const from = positions[start];
+    const to = positions[end];
+    for (let gap = index; gap < end; gap++) {
+      positions[gap] = from + (to - from) * (gap - start) / (end - start);
+    }
+  }
+  return raw.map((stop, index) => ({
+    color: stop.color,
+    position: Math.max(0, Math.min(1, positions[index]))
+  }));
+}
+function borrowTransparentHues(stops) {
+  return stops.map((stop, index) => {
+    if (stop.color.alpha > 0) return stop;
+    const neighbour = stops.slice(index + 1).find((candidate) => candidate.color.alpha > 0) ?? [...stops.slice(0, index)].reverse().find((candidate) => candidate.color.alpha > 0);
+    return neighbour ? { ...stop, color: { hex: neighbour.color.hex, alpha: 0 } } : stop;
+  });
+}
+function parseCssGradient(value) {
+  const match = /(linear|radial)-gradient\(\s*([\s\S]*)\)\s*$/i.exec(value.trim());
+  if (!match) return null;
+  const kind = match[1].toLowerCase();
+  const args = splitTopLevel(match[2]);
+  if (args.length === 0) return null;
+  const first = args[0];
+  let angle = 180;
+  let center = { x: 0.5, y: 0.5 };
+  let stopTokens = args;
+  if (kind === "linear") {
+    const parsed = parseAngle(first);
+    if (parsed !== null) {
+      angle = parsed;
+      stopTokens = args.slice(1);
+    }
+  } else if (/^(circle|ellipse|closest-|farthest-|at\s)/i.test(first) || /\bat\s/i.test(first)) {
+    center = parseRadialCenter(first);
+    stopTokens = args.slice(1);
+  }
+  const raw = stopTokens.flatMap((token) => parseStop(token) ?? []);
+  if (raw.length < 2) return null;
+  const stops = borrowTransparentHues(resolveStopPositions(raw));
+  return kind === "linear" ? { kind, angle, stops } : { kind, centerX: center.x, centerY: center.y, stops };
+}
+function isOpaqueGradient(gradient) {
+  return gradient.stops.every((stop) => stop.color.alpha >= 1e5);
+}
+function cssGradientFillXml(gradient, opacity = 1) {
+  const factor = Math.max(0, Math.min(1, opacity));
+  const stops = gradient.stops.map(({ color, position }) => {
+    const alpha = Math.round(color.alpha * factor);
+    return `<a:gs pos="${Math.round(position * 1e5)}"><a:srgbClr val="${color.hex}">` + (alpha < 1e5 ? `<a:alpha val="${alpha}"/>` : "") + `</a:srgbClr></a:gs>`;
+  }).join("");
+  if (gradient.kind === "linear") {
+    const angle = Math.round(((gradient.angle - 90) % 360 + 360) % 360 * 6e4);
+    return `<a:gradFill rotWithShape="1"><a:gsLst>${stops}</a:gsLst><a:lin ang="${angle}" scaled="0"/></a:gradFill>`;
+  }
+  const edge = (value) => Math.round(Math.max(0, Math.min(1, value)) * 1e5);
+  return `<a:gradFill rotWithShape="1"><a:gsLst>${stops}</a:gsLst><a:path path="circle"><a:fillToRect l="${edge(gradient.centerX)}" t="${edge(gradient.centerY)}" r="${edge(1 - gradient.centerX)}" b="${edge(1 - gradient.centerY)}"/></a:path></a:gradFill>`;
+}
+function blendOver(dst, src) {
+  const alpha = Math.max(0, Math.min(1, src.alpha / 1e5));
+  const channel = (offset) => {
+    const under = Number.parseInt(dst.slice(offset, offset + 2), 16);
+    const over = Number.parseInt(src.hex.slice(offset, offset + 2), 16);
+    return Math.round(over * alpha + under * (1 - alpha)).toString(16).padStart(2, "0");
+  };
+  return `${channel(0)}${channel(2)}${channel(4)}`.toUpperCase();
+}
+function cssGradientToString(gradient) {
+  const stops = gradient.stops.map(({ color, position }) => {
+    const alpha = color.alpha / 1e5;
+    const value = alpha >= 1 ? `#${color.hex}` : `rgba(${Number.parseInt(color.hex.slice(0, 2), 16)}, ${Number.parseInt(color.hex.slice(2, 4), 16)}, ${Number.parseInt(color.hex.slice(4, 6), 16)}, ${alpha})`;
+    return `${value} ${+(position * 100).toFixed(3)}%`;
+  }).join(", ");
+  return gradient.kind === "linear" ? `linear-gradient(${gradient.angle}deg, ${stops})` : `radial-gradient(ellipse at ${+(gradient.centerX * 100).toFixed(3)}% ${+(gradient.centerY * 100).toFixed(3)}%, ${stops})`;
+}
+
+// src/pptx/drawingXml.ts
+function officeTypeface(family, fallback) {
+  const resolved = resolveFontFamily(family, fallback);
+  const first = resolved.split(",")[0]?.trim().replace(/^['"]|['"]$/g, "");
+  return first || fallback;
+}
+function solidColorXml(color) {
+  const alpha = color.alpha < 1e5 ? `<a:alpha val="${color.alpha}"/>` : "";
+  return `<a:solidFill><a:srgbClr val="${color.hex}">${alpha}</a:srgbClr></a:solidFill>`;
+}
+function fillXml(fill, opacity, gradient) {
+  if (gradient) return gradientFillXml(gradient.from, gradient.to, gradient.angle ?? 0, opacity);
+  if (!fill || fill === "none" || fill === "transparent") return "<a:noFill/>";
+  if (fill.includes("gradient(")) {
+    const parsed = parseCssGradient(fill);
+    if (parsed) return cssGradientFillXml(parsed, opacity ?? 1);
+    const colors = fill.match(/#[0-9a-f]{3,8}|rgba?\([^)]*\)/gi) ?? [];
+    if (colors.length >= 2) {
+      const angle = Number.parseFloat(
+        /(?:linear-gradient\()\s*([\d.-]+)deg/i.exec(fill)?.[1] ?? "0"
+      );
+      return gradientFillXml(colors[0], colors[colors.length - 1], angle, opacity);
+    }
+  }
+  const color = parseCssColor(fill, "000000");
+  if (opacity !== void 0)
+    color.alpha = Math.round(color.alpha * Math.max(0, Math.min(1, opacity)));
+  return solidColorXml(color);
+}
+function gradientFillXml(from, to, angle, opacity) {
+  const first = parseCssColor(from, "000000");
+  const second = parseCssColor(to, first.hex);
+  if (opacity !== void 0) {
+    const factor = Math.max(0, Math.min(1, opacity));
+    first.alpha = Math.round(first.alpha * factor);
+    second.alpha = Math.round(second.alpha * factor);
+  }
+  const ooxmlAngle = Math.round(((90 - angle) % 360 + 360) % 360 * 6e4);
+  return `<a:gradFill rotWithShape="1"><a:gsLst><a:gs pos="0"><a:srgbClr val="${first.hex}">${first.alpha < 1e5 ? `<a:alpha val="${first.alpha}"/>` : ""}</a:srgbClr></a:gs><a:gs pos="100000"><a:srgbClr val="${second.hex}">${second.alpha < 1e5 ? `<a:alpha val="${second.alpha}"/>` : ""}</a:srgbClr></a:gs></a:gsLst><a:lin ang="${ooxmlAngle}" scaled="1"/></a:gradFill>`;
+}
+function lineXml(color, widthPx, borderStyle) {
+  if (!color || !widthPx || widthPx <= 0) return "<a:ln><a:noFill/></a:ln>";
+  const width = Math.max(1, Math.round(widthPx * EMU_PER_CANVAS_PX));
+  return `<a:ln w="${width}">${solidColorXml(parseCssColor(color, "000000"))}${dashXml(borderStyle)}</a:ln>`;
+}
+function dashXml(style, dasharray) {
+  if (style === "dashed" || dasharray && dasharray !== "none") return '<a:prstDash val="dash"/>';
+  if (style === "dotted") return '<a:prstDash val="dot"/>';
+  return "";
+}
+function patternFillXml(pattern, ground) {
+  const size = pattern.size ?? 24;
+  const preset = pattern.kind === "dots" ? "pct5" : pattern.kind === "grid" ? size >= 32 ? "lgGrid" : "smGrid" : size >= 32 ? "wdUpDiag" : "ltUpDiag";
+  const ink = parseCssColor(pattern.color, "FFFFFF");
+  ink.alpha = Math.round(ink.alpha * Math.max(0, Math.min(1, pattern.opacity ?? 1)));
+  const alpha = ink.alpha < 1e5 ? `<a:alpha val="${ink.alpha}"/>` : "";
+  return `<a:pattFill prst="${preset}"><a:fgClr><a:srgbClr val="${ink.hex}">${alpha}</a:srgbClr></a:fgClr>` + (ground ? `<a:bgClr><a:srgbClr val="${parseCssColor(ground, "000000").hex}"/></a:bgClr>` : `<a:bgClr><a:srgbClr val="${ink.hex}"><a:alpha val="0"/></a:srgbClr></a:bgClr>`) + `</a:pattFill>`;
+}
+function buildLayerShape(layer, shapeId) {
+  const rect = toEmuRect(resolveLayerRect(layer.position, 100, 100));
+  const geometry = layer.content.shape === "circle" ? "ellipse" : layer.content.shape === "line" ? "line" : layer.content.borderRadius ? "roundRect" : "rect";
+  const fill = layer.content.shape === "line" ? "<a:noFill/>" : layer.content.pattern ? patternFillXml(layer.content.pattern) : fillXml(layer.content.fill, layer.content.fillOpacity, layer.content.gradient);
+  const stroke = lineXml(
+    layer.content.stroke ?? (layer.content.shape === "line" ? "#ffffff" : void 0),
+    layer.content.strokeWidth ?? (layer.content.shape === "line" ? 2 : void 0),
+    layer.content.borderStyle
+  );
+  return `<p:sp><p:nvSpPr><p:cNvPr id="${shapeId}" name="${escapeXml(layer.id)}"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr><p:spPr><a:xfrm><a:off x="${rect.x}" y="${rect.y}"/><a:ext cx="${rect.width}" cy="${rect.height}"/></a:xfrm><a:prstGeom prst="${geometry}"><a:avLst/></a:prstGeom>` + fill + stroke + `</p:spPr></p:sp>`;
+}
+
+// src/pptx/backdrop.ts
+import { TEMPLATE_METADATA } from "@bendyline/squisq/doc";
+import { isSvgImageSource } from "@bendyline/squisq/markdown";
+var FULL_BLEED_TOLERANCE_PX = 1;
+function coversCanvas(layer) {
+  if (layer.position.width == null || layer.position.height == null) return false;
+  const rect = resolveLayerRect(layer.position, 1920, 1080);
+  return rect.x <= FULL_BLEED_TOLERANCE_PX && rect.y <= FULL_BLEED_TOLERANCE_PX && rect.x + rect.width >= 1920 - FULL_BLEED_TOLERANCE_PX && rect.y + rect.height >= 1080 - FULL_BLEED_TOLERANCE_PX;
+}
+function isPaintRect(layer) {
+  if (layer.type !== "shape" || layer.content.shape !== "rect") return false;
+  if (layer.content.borderRadius) return false;
+  if (layer.content.stroke && (layer.content.strokeWidth ?? 1) > 0) return false;
+  return coversCanvas(layer);
+}
+function isPhotoBackdrop(layer) {
+  return layer.type === "image" && (!layer.content.src || layer.content.fit === "cover" || layer.content.fit === "fill") && !(layer.content.src && isSvgImageSource(layer.content.src)) && coversCanvas(layer);
+}
+function isOpaqueColor(color, opacity) {
+  if (!color || color === "none" || color === "transparent") return false;
+  return parseCssColor(color, "000000").alpha >= 1e5 && (opacity ?? 1) >= 1;
+}
+function isOpaquePaint(layer) {
+  if (layer.type === "image") return !!layer.content.src;
+  const { fill, fillOpacity, gradient, pattern, filter } = layer.content;
+  if (pattern || filter) return false;
+  if (gradient) {
+    return isOpaqueColor(gradient.from, fillOpacity) && isOpaqueColor(gradient.to, fillOpacity);
+  }
+  if (fill?.includes("gradient(")) {
+    const parsed = parseCssGradient(fill);
+    return !!parsed && isOpaqueGradient(parsed) && (fillOpacity ?? 1) >= 1;
+  }
+  return isOpaqueColor(fill, fillOpacity);
+}
+function isDrawable(layer) {
+  return layer.content.filter?.type !== "noise";
+}
+var CLEAR = { hex: "000000", alpha: 0 };
+function layerPaint(layer) {
+  const { fill, fillOpacity, gradient, pattern } = layer.content;
+  const factor = Math.max(0, Math.min(1, fillOpacity ?? 1));
+  const fade = (color) => ({
+    hex: color.hex,
+    alpha: Math.round(color.alpha * factor)
+  });
+  if (pattern) return { kind: "pattern", pattern };
+  if (gradient) {
+    return {
+      kind: "gradient",
+      gradient: {
+        kind: "linear",
+        angle: 180 - (gradient.angle ?? 0),
+        stops: [
+          { position: 0, color: fade(parseCssColor(gradient.from, "000000")) },
+          { position: 1, color: fade(parseCssColor(gradient.to, "000000")) }
+        ]
+      }
+    };
+  }
+  if (!fill || fill === "none" || fill === "transparent") return { kind: "solid", color: CLEAR };
+  if (fill.includes("gradient(")) {
+    const parsed = parseCssGradient(fill);
+    if (!parsed) return null;
+    const stops = parsed.stops.map((stop) => ({ ...stop, color: fade(stop.color) }));
+    return { kind: "gradient", gradient: { ...parsed, stops } };
+  }
+  return { kind: "solid", color: fade(parseCssColor(fill, "000000")) };
+}
+function compositeBackdrop(base, overlays) {
+  const paints = [base, ...overlays].map(layerPaint);
+  if (paints.some((paint) => paint === null)) return null;
+  const stack = paints;
+  const varying = stack.filter((paint) => paint.kind !== "solid");
+  if (varying.length > 1 || stack[0].kind === "pattern") return null;
+  const uniform = (paint) => paint.kind === "solid" ? paint.color : CLEAR;
+  const fold = (sample) => stack.reduce((under, paint) => blendOver(under, sample(paint)), "000000");
+  const only = varying[0];
+  let content;
+  if (!only) {
+    content = { shape: "rect", fill: `#${fold(uniform)}` };
+  } else if (only.kind === "gradient") {
+    const stops = only.gradient.stops.map((stop) => ({
+      position: stop.position,
+      color: {
+        hex: fold((paint) => paint === only ? stop.color : uniform(paint)),
+        alpha: 1e5
+      }
+    }));
+    content = { shape: "rect", fill: cssGradientToString({ ...only.gradient, stops }) };
+  } else {
+    const ink = parseCssColor(only.pattern.color, "FFFFFF");
+    ink.alpha = Math.round(ink.alpha * Math.max(0, Math.min(1, only.pattern.opacity ?? 1)));
+    content = {
+      shape: "rect",
+      // The ground under the motif, and the motif's ink over that ground.
+      fill: `#${fold(uniform)}`,
+      pattern: {
+        ...only.pattern,
+        color: `#${fold((paint) => paint === only ? ink : uniform(paint))}`,
+        opacity: 1
+      }
+    };
+  }
+  return { ...base, content };
+}
+function splitSlideBackdrop(layers) {
+  let start = 0;
+  while (start < layers.length && (isPaintRect(layers[start]) || isPhotoBackdrop(layers[start]))) {
+    start++;
+  }
+  let end = layers.length;
+  while (end > start) {
+    const layer = layers[end - 1];
+    if (!isPaintRect(layer) || isOpaquePaint(layer)) break;
+    end--;
+  }
+  const under = layers.slice(0, start);
+  let baseIndex = -1;
+  for (let index = under.length - 1; index >= 0; index--) {
+    if (isOpaquePaint(under[index])) {
+      baseIndex = index;
+      break;
+    }
+  }
+  const overlays = [...under.slice(baseIndex + 1), ...layers.slice(end)].filter(
+    (layer) => layer.type === "shape" && isDrawable(layer)
+  );
+  return {
+    base: baseIndex >= 0 ? under[baseIndex] : null,
+    overlays,
+    content: layers.slice(start, end)
+  };
+}
+function compositeAsFarAsPossible(base, overlays) {
+  if (base?.type !== "shape") return { base, overlays };
+  for (let count = overlays.length; count > 0; count--) {
+    const flat = compositeBackdrop(base, overlays.slice(0, count));
+    if (flat) return { base: flat, overlays: overlays.slice(count) };
+  }
+  return { base, overlays };
+}
+function paintSignature(layer) {
+  const { id: _id, animation: _animation, ...rest } = layer;
+  return JSON.stringify(rest);
+}
+function isSolidPaint(layer) {
+  const { fill, gradient, pattern } = layer.content;
+  return !gradient && !pattern && !fill?.includes("gradient(");
+}
+function mostCommonPaint(items) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const entry = counts.get(paintSignature(item));
+    if (entry) entry.count++;
+    else counts.set(paintSignature(item), { item, count: 1 });
+  }
+  let best = null;
+  for (const entry of counts.values()) {
+    if (!best || entry.count > best.count || entry.count === best.count && isSolidPaint(entry.item) && !isSolidPaint(best.item)) {
+      best = entry;
+    }
+  }
+  return best?.item ?? null;
+}
+function layoutLabel(block) {
+  if (block.template) return TEMPLATE_METADATA[block.template]?.label ?? block.template;
+  return block.id === "cover-block" ? "Cover" : "Slide";
+}
+function planDeckBackdrops(blocks) {
+  const raw = blocks.map((block) => splitSlideBackdrop(block.layers ?? []));
+  let masterOverlays = (raw[0]?.overlays ?? []).filter(
+    (overlay) => overlay.id.startsWith("persistent-") && raw.every(
+      (slide) => slide.overlays.some((other) => paintSignature(other) === paintSignature(overlay))
+    )
+  );
+  const masterSignatures = new Set(masterOverlays.map(paintSignature));
+  const split = raw.map((slide) => ({
+    ...compositeAsFarAsPossible(
+      slide.base,
+      slide.overlays.filter((overlay) => !masterSignatures.has(paintSignature(overlay)))
+    ),
+    content: slide.content
+  }));
+  const slideOverlays = split.map((slide) => slide.overlays);
+  const paintBases = split.map((slide) => slide.base).filter((base) => base?.type === "shape");
+  let masterBase = mostCommonPaint(paintBases);
+  const masterBaseSignature = masterBase ? paintSignature(masterBase) : null;
+  const layouts = [];
+  const layoutKeys = /* @__PURE__ */ new Map();
+  const groups = [];
+  blocks.forEach((block, index) => {
+    const key = `${layoutLabel(block)}\0${slideOverlays[index].map(paintSignature).join("\0")}`;
+    let layout = layoutKeys.get(key);
+    if (layout === void 0) {
+      layout = layouts.length;
+      layoutKeys.set(key, layout);
+      const label = layoutLabel(block);
+      const taken = layouts.filter((existing) => existing.name.replace(/ \d+$/, "") === label);
+      layouts.push({
+        name: taken.length ? `${label} ${taken.length + 1}` : label,
+        base: null,
+        overlays: slideOverlays[index]
+      });
+      groups.push([]);
+    }
+    groups[layout].push(index);
+  });
+  const slides = blocks.map(() => ({ layout: 0, base: null, content: [] }));
+  groups.forEach((members, layoutIndex) => {
+    const layout = layouts[layoutIndex];
+    const groupBase = mostCommonPaint(
+      members.map((index) => split[index].base).filter((base) => base?.type === "shape")
+    );
+    if (groupBase && paintSignature(groupBase) !== masterBaseSignature) layout.base = groupBase;
+    const inherited = layout.base ?? masterBase;
+    const inheritedSignature = inherited ? paintSignature(inherited) : null;
+    for (const index of members) {
+      const { base, content } = split[index];
+      slides[index] = {
+        layout: layoutIndex,
+        base: base && paintSignature(base) !== inheritedSignature ? base : null,
+        content
+      };
+    }
+  });
+  if (masterBase && masterOverlays.length > 0 && layouts.every((layout) => !layout.base) && slides.every((slide) => !slide.base)) {
+    const flat = compositeBackdrop(masterBase, masterOverlays);
+    if (flat) {
+      masterBase = flat;
+      masterOverlays = [];
+    }
+  }
+  return { master: { base: masterBase, overlays: masterOverlays }, layouts, slides };
+}
+
+// src/pptx/layerText.ts
+import { splitIconMarkers as splitIconMarkers2 } from "@bendyline/squisq/icon-marker";
+
+// src/pptx/textFit.ts
+import { resolveFontFamily as resolveFontFamily2 } from "@bendyline/squisq/schemas";
+import { hasIconMarker, splitIconMarkers } from "@bendyline/squisq/icon-marker";
+var CANVAS_WIDTH = 1920;
+var CANVAS_HEIGHT = 1080;
+var MAX_TEXT_SCALE = 2;
+var FIT_TOLERANCE_PX = 1;
+var PARAGRAPH_GAP_EM = 0.4;
+var LIST_GAP_EM = 0.7;
+var LIST_INDENT_EM = 1.2;
+var MONO_FONT = /\b(mono|monospace|courier|consolas|menlo|monaco)\b/;
+var SERIF_FONT = /\b(serif|georgia|times|garamond|playfair|merriweather|lora|baskerville|cambria|palatino|didot|bodoni)\b/;
+function averageCharEm(style, basis = "office") {
+  const first = resolveFontFamily2(style.fontFamily, "sans-serif").split(",")[0].trim().replace(/^['"]|['"]$/g, "").toLowerCase();
+  const serif = !first.includes("sans") && SERIF_FONT.test(first);
+  const base = MONO_FONT.test(first) ? 0.6 : basis === "browser" ? serif ? 0.5 : 0.44 : serif ? 0.52 : 0.48;
+  return style.fontWeight === "bold" ? base * 1.07 : base;
+}
+function wrapByChars(text, charsPerLine) {
+  if (!text.trim()) return [""];
+  if (charsPerLine <= 0) return [text];
+  const lines = [];
+  let current = "";
+  for (const word of text.split(/\s+/)) {
+    const candidate = current ? `${current} ${word}` : word;
+    if (candidate.length <= charsPerLine) {
+      current = candidate;
+      continue;
+    }
+    if (current) lines.push(current);
+    let remaining = word;
+    while (remaining.length > charsPerLine) {
+      lines.push(remaining.slice(0, charsPerLine));
+      remaining = remaining.slice(charsPerLine);
+    }
+    current = remaining;
+  }
+  if (current) lines.push(current);
+  return lines.length > 0 ? lines : [""];
+}
+function measurableText(text) {
+  return splitIconMarkers(text).map((run) => run.type === "text" ? run.text : "M").join("");
+}
+function isHtmlText(layer) {
+  return Boolean(layer.content.html?.trim()) || hasIconMarker(layer.content.text ?? "");
+}
+function hasBlockGaps(layer) {
+  return Boolean(layer.content.html?.trim());
+}
+function layerParagraphs(layer) {
+  return layer.content.paragraphs ?? (layer.content.text ?? "").split("\n").map((text) => ({ text }));
+}
+function blockGapsEm(paragraphs, lineHeight) {
+  let pending = 0;
+  let previous;
+  return paragraphs.map((paragraph) => {
+    if (!paragraph.text.trim() && !paragraph.list) {
+      pending++;
+      return null;
+    }
+    const gap = previous && pending > 0 ? (previous.list ? LIST_GAP_EM : PARAGRAPH_GAP_EM) + (pending - 1) * lineHeight : 0;
+    pending = 0;
+    previous = paragraph;
+    return gap;
+  });
+}
+function estimateFlowHeight(paragraphs, style, widthPx, blockGaps) {
+  const fontSize = style.fontSize;
+  const lineHeight = style.lineHeight ?? 1.4;
+  const advance = averageCharEm(style) * fontSize;
+  const gaps = blockGaps ? blockGapsEm(paragraphs, lineHeight) : void 0;
+  let height = 0;
+  paragraphs.forEach((paragraph, index) => {
+    const gap = gaps?.[index];
+    if (gap === null) return;
+    height += (gap ?? 0) * fontSize + (paragraph.spaceBefore ?? 0);
+    const indent = paragraph.list ? LIST_INDENT_EM * fontSize * (paragraph.list.level + 1) : 0;
+    const charsPerLine = Math.floor(Math.max(advance, widthPx - indent) / advance);
+    const lines = measurableText(paragraph.text).split("\n").reduce((count, line) => count + wrapByChars(line, charsPerLine).length, 0);
+    height += lines * lineHeight * fontSize;
+  });
+  return height;
+}
+function htmlContentWidth(layer) {
+  const { position, content } = layer;
+  const { style } = content;
+  const border = style.borderColor && (style.borderWidth ?? 0) > 0 ? style.borderWidth : 0;
+  const boxWidth = position.width != null ? resolvePositionValue(position.width, CANVAS_WIDTH) : CANVAS_WIDTH;
+  return Math.max(1, boxWidth - ((style.padding ?? 0) + border) * 2);
+}
+function estimateTextHeight(layer, scale, listIndentPx = 0) {
+  const { style } = layer.content;
+  if (isHtmlText(layer)) {
+    return estimateFlowHeight(
+      layerParagraphs(layer),
+      { ...style, fontSize: style.fontSize * scale },
+      htmlContentWidth(layer),
+      hasBlockGaps(layer)
+    );
+  }
+  const boxWidth = layer.position.width != null ? resolvePositionValue(layer.position.width, CANVAS_WIDTH) : void 0;
+  const lineHeight = (style.lineHeight ?? 1.4) * style.fontSize * scale;
+  let lineCount = 0;
+  let spacing = 0;
+  for (const paragraph of layerParagraphs(layer)) {
+    spacing += paragraph.spaceBefore ?? 0;
+    const indent = paragraph.list ? listIndentPx * (paragraph.list.level + 1) : 0;
+    const charsPerLine = boxWidth == null ? void 0 : Math.floor((boxWidth - indent) / (style.fontSize * 0.5));
+    for (const line of measurableText(paragraph.text).split("\n")) {
+      lineCount += charsPerLine == null ? 1 : wrapByChars(line, charsPerLine).length;
+    }
+  }
+  if (style.maxLines) lineCount = Math.min(lineCount, style.maxLines);
+  return lineCount * lineHeight + spacing;
+}
+function anchorOffset(anchor, size, axis) {
+  if (anchor === "center") return size / 2;
+  if (axis === "x") return anchor.includes("right") ? size : 0;
+  return anchor.includes("bottom") ? size : 0;
+}
+function svgTarget(layer) {
+  const { position, content } = layer;
+  const { style } = content;
+  const anchor = position.anchor ?? "top-left";
+  const rawX = resolvePositionValue(position.x, CANVAS_WIDTH);
+  const rawY = resolvePositionValue(position.y, CANVAS_HEIGHT);
+  const boxWidth = position.width != null ? resolvePositionValue(position.width, CANVAS_WIDTH) : void 0;
+  const boxHeight = position.height != null ? resolvePositionValue(position.height, CANVAS_HEIGHT) : void 0;
+  const textAnchor = style.textAlign === "center" ? "middle" : style.textAlign === "right" ? "end" : style.textAlign === "left" ? "start" : anchor.includes("right") ? "end" : anchor === "center" ? "middle" : "start";
+  const baseline = style.verticalAlign === "top" ? "before" : style.verticalAlign === "middle" ? "middle" : style.verticalAlign === "bottom" ? "after" : anchor.includes("bottom") ? "after" : anchor === "center" ? "middle" : "before";
+  let x = rawX;
+  if (boxWidth != null) {
+    const left = rawX - anchorOffset(anchor, boxWidth, "x");
+    x = textAnchor === "middle" ? left + boxWidth / 2 : textAnchor === "end" ? left + boxWidth : left;
+  }
+  let y = rawY;
+  if (boxHeight != null) {
+    const top = rawY - anchorOffset(anchor, boxHeight, "y");
+    y = baseline === "middle" ? top + boxHeight / 2 : baseline === "after" ? top + boxHeight : top;
+  }
+  const fitWidth = boxWidth ?? (textAnchor === "middle" ? Math.max(0, Math.min(x, CANVAS_WIDTH - x) * 2) : textAnchor === "end" ? Math.max(0, x) : Math.max(0, CANVAS_WIDTH - x));
+  const fitHeight = boxHeight ?? (baseline === "middle" ? Math.max(0, Math.min(y, CANVAS_HEIGHT - y) * 2) : baseline === "after" ? Math.max(0, y) : Math.max(0, CANVAS_HEIGHT - y));
+  let lines = measurableText(content.text ?? "").split("\n");
+  if (boxWidth != null) {
+    const playerChars = Math.floor(boxWidth / (style.fontSize * 0.5));
+    lines = lines.flatMap((line) => wrapByChars(line, playerChars));
+  }
+  if (style.maxLines && lines.length > style.maxLines) lines = lines.slice(0, style.maxLines);
+  const longest = Math.max(...lines.map((line) => line.length));
+  if (longest === 0) return null;
+  const width = longest * averageCharEm(style, "browser") * style.fontSize;
+  const height = estimateTextHeight(layer, 1);
+  return {
+    fits: (scale) => width * scale <= fitWidth + FIT_TOLERANCE_PX && height * scale <= fitHeight + FIT_TOLERANCE_PX,
+    rect: (scale) => {
+      const w = width * scale;
+      const h = height * scale;
+      const left = textAnchor === "middle" ? x - w / 2 : textAnchor === "end" ? x - w : x;
+      const top = baseline === "middle" ? y - h / 2 : baseline === "after" ? y - h : y;
+      return { left, top, right: left + w, bottom: top + h };
+    }
+  };
+}
+function htmlTarget(layer) {
+  const { position, content } = layer;
+  const { style } = content;
+  const anchor = position.anchor ?? "top-left";
+  const lineHeight = style.lineHeight ?? 1.4;
+  const padding = style.padding ?? 0;
+  const border = style.borderColor && (style.borderWidth ?? 0) > 0 ? style.borderWidth : 0;
+  const rich = hasBlockGaps(layer);
+  const boxWidth = position.width != null ? resolvePositionValue(position.width, CANVAS_WIDTH) : CANVAS_WIDTH;
+  const plain = measurableText(content.text ?? "");
+  const boxHeight = position.height != null ? resolvePositionValue(position.height, CANVAS_HEIGHT) : rich ? style.fontSize * lineHeight * 2 : Math.max(
+    1,
+    plain.split("\n").flatMap((line) => wrapByChars(line, Math.floor(boxWidth / (style.fontSize * 0.5)))).length
+  ) * style.fontSize * lineHeight + padding * 2;
+  const inset = padding + border;
+  const left = resolvePositionValue(position.x, CANVAS_WIDTH) - anchorOffset(anchor, boxWidth, "x");
+  const top = resolvePositionValue(position.y, CANVAS_HEIGHT) - anchorOffset(anchor, boxHeight, "y");
+  const availableWidth = Math.max(1, boxWidth - inset * 2);
+  const availableHeight = Math.max(0, boxHeight - inset * 2);
+  const paragraphs = layerParagraphs(layer);
+  if (!paragraphs.some((paragraph) => paragraph.text.trim())) return null;
+  const justify = rich ? style.verticalAlign ?? "top" : style.verticalAlign === "top" || style.verticalAlign === "bottom" ? style.verticalAlign : "middle";
+  const heightAt = (scale) => estimateTextHeight(layer, scale);
+  return {
+    fits: (scale) => heightAt(scale) <= availableHeight + FIT_TOLERANCE_PX,
+    rect: (scale) => {
+      const h = heightAt(scale);
+      const contentTop = justify === "middle" ? top + (boxHeight - h) / 2 : justify === "bottom" ? top + boxHeight - inset - h : top + inset;
+      return {
+        left: left + inset,
+        top: contentTop,
+        right: left + inset + availableWidth,
+        bottom: contentTop + h
+      };
+    }
+  };
+}
+function overlapPairs(rects) {
+  const pairs = /* @__PURE__ */ new Set();
+  for (let a = 0; a < rects.length; a++) {
+    for (let b = a + 1; b < rects.length; b++) {
+      const one = rects[a];
+      const two = rects[b];
+      if (one.left < two.right - FIT_TOLERANCE_PX && one.right > two.left + FIT_TOLERANCE_PX && one.top < two.bottom - FIT_TOLERANCE_PX && one.bottom > two.top + FIT_TOLERANCE_PX) {
+        pairs.add(`${a}:${b}`);
+      }
+    }
+  }
+  return pairs;
+}
+function estimateSlideTextScale(layers) {
+  const targets = layers.filter((layer) => layer.type === "text").map((layer) => isHtmlText(layer) ? htmlTarget(layer) : svgTarget(layer)).filter((target) => target !== null);
+  if (targets.length === 0) return 1;
+  const baseline = overlapPairs(targets.map((target) => target.rect(1)));
+  const fits = (scale) => {
+    if (!targets.every((target) => target.fits(scale))) return false;
+    for (const pair of overlapPairs(targets.map((target) => target.rect(scale)))) {
+      if (!baseline.has(pair)) return false;
+    }
+    return true;
+  };
+  if (!fits(1)) return 1;
+  if (fits(MAX_TEXT_SCALE)) return MAX_TEXT_SCALE;
+  let low = 1;
+  let high = MAX_TEXT_SCALE;
+  for (let attempt = 0; attempt < 10; attempt++) {
+    const candidate = (low + high) / 2;
+    if (fits(candidate)) low = candidate;
+    else high = candidate;
+  }
+  return Math.max(1, Math.floor(low * 100) / 100);
+}
+
+// src/pptx/textLists.ts
+function mergeTextFlows(layers, textScale = 1) {
+  const flows = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    if (layer.type !== "text" || !layer.content.flow) continue;
+    const members = flows.get(layer.content.flow.id) ?? [];
+    members.push(layer);
+    flows.set(layer.content.flow.id, members);
+  }
+  const units = [];
+  const emitted = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    const flowId = layer.type === "text" ? layer.content.flow?.id : void 0;
+    const members = flowId === void 0 ? void 0 : flows.get(flowId);
+    const bodies = members?.filter((member) => member.content.flow?.role !== "marker") ?? [];
+    if (flowId === void 0 || !members || !bodies.some((body) => body.content.paragraphs)) {
+      units.push({ layer });
+      continue;
+    }
+    if (emitted.has(flowId)) continue;
+    emitted.add(flowId);
+    const rects = members.map((member) => {
+      const { fontSize, lineHeight } = member.content.style;
+      return resolveLayerRect(
+        member.position,
+        Math.max(fontSize, member.content.text.length * fontSize * 0.55),
+        fontSize * (lineHeight ?? 1.4)
+      );
+    });
+    const left = Math.min(...rects.map((rect) => rect.x));
+    const top = Math.min(...rects.map((rect) => rect.y));
+    const right = Math.max(...rects.map((rect) => rect.x + rect.width));
+    const bottom = Math.max(...rects.map((rect) => rect.y + rect.height));
+    const first = bodies[0];
+    const indent = rects[members.indexOf(first)].x - left;
+    const paragraphs = bodies.flatMap((body, index) => {
+      const own = body.content.paragraphs ?? [{ text: body.content.text }];
+      const previous = bodies[index - 1];
+      if (!previous || own.length === 0) return own;
+      const previousRect = rects[members.indexOf(previous)];
+      const gap = rects[members.indexOf(body)].y - (previousRect.y + estimateTextHeight(previous, textScale));
+      const [head, ...rest] = own;
+      return [{ ...head, spaceBefore: Math.max(0, gap) }, ...rest];
+    });
+    units.push({
+      layer: {
+        ...first,
+        id: flowId,
+        position: { x: left, y: top, width: right - left, height: bottom - top },
+        content: {
+          text: bodies.map((body) => body.content.text).join("\n"),
+          paragraphs,
+          style: first.content.style
+        }
+      },
+      ...indent > 0 ? { listIndentPx: indent } : {}
+    });
+  }
+  return units;
+}
+function planListParagraphs(paragraphs) {
+  const runs = [];
+  return paragraphs.map(({ list }) => {
+    if (!list) {
+      runs.length = 0;
+      return void 0;
+    }
+    const level = Math.min(8, Math.max(0, Math.floor(list.level)));
+    runs.length = Math.min(runs.length, level + 1);
+    if (!list.ordered) {
+      runs[level] = void 0;
+      return { ordered: false, level };
+    }
+    const number = list.number ?? 1;
+    const run = runs[level];
+    if (run && run.next === number) run.next++;
+    else runs[level] = { start: number, next: number + 1 };
+    return { ordered: true, level, startAt: runs[level].start };
+  });
+}
+function listParagraphXml(plan, indentPx) {
+  const hang = Math.round(indentPx * EMU_PER_CANVAS_PX);
+  const startAt = plan.startAt && plan.startAt !== 1 ? ` startAt="${plan.startAt}"` : "";
+  return {
+    attributes: ` marL="${hang * (plan.level + 1)}" lvl="${plan.level}" indent="${-hang}"`,
+    bullet: plan.ordered ? `<a:buAutoNum type="arabicPeriod"${startAt}/>` : `<a:buChar char="\u2022"/>`
+  };
+}
+
+// src/pptx/layerText.ts
+function buildLayerTextShape(layer, shapeId, maxBottom, listIndentPx, textScale = 1) {
+  const sourceText = layer.content.text ?? "";
+  const text = measurableText(sourceText);
+  const baseStyle = layer.content.style;
+  const style = textScale === 1 ? baseStyle : { ...baseStyle, fontSize: baseStyle.fontSize * textScale };
+  const padding = style.padding ?? 0;
+  const rawLines = text.split("\n");
+  const charEm = averageCharEm(style);
+  const estimatedWidth = Math.min(
+    1920,
+    Math.max(
+      1,
+      Math.max(...rawLines.map((line) => line.length), 1) * style.fontSize * // A box sized to the text must not wrap it when Office's face for
+      // the CSS stack runs a little wider than the estimate.
+      Math.max(0.55, charEm * 1.15) + padding * 2
+    )
+  );
+  const boxWidth = layer.position.width != null ? resolvePositionValue(layer.position.width, 1920) : estimatedWidth;
+  const fittedFontSize = rawLines.length === 1 && style.fontSize >= 80 && text.length > 0 ? Math.min(style.fontSize, (boxWidth - padding * 2) / (text.length * charEm * 1.05)) : style.fontSize;
+  const blockGaps = hasBlockGaps(layer);
+  const paragraphSource = layerParagraphs(layer);
+  const neededHeight = Math.max(
+    fittedFontSize * (style.lineHeight ?? 1.4),
+    estimateTextHeight(layer, fittedFontSize / baseStyle.fontSize, listIndentPx)
+  );
+  const reserve = fittedFontSize * OFFICE_TEXT_RESERVE_EM;
+  const estimatedHeight = neededHeight + reserve + padding * 2;
+  const resolvedRect = resolveLayerRect(layer.position, boxWidth, estimatedHeight);
+  const safeBottom = Math.min(1060, maxBottom ?? 1060);
+  const vertical = style.verticalAlign === "bottom" ? "b" : style.verticalAlign === "middle" ? "ctr" : "t";
+  let virtualRect = {
+    ...resolvedRect,
+    y: Math.min(resolvedRect.y, safeBottom - 1),
+    height: Math.max(1, Math.min(resolvedRect.height, safeBottom - resolvedRect.y))
+  };
+  const visibleBox = !!style.background || !!style.backgroundGradient || !!(style.borderColor && (style.borderWidth ?? 0) > 0);
+  if (!visibleBox && virtualRect.height < estimatedHeight) {
+    const extra = estimatedHeight - virtualRect.height;
+    const above = vertical === "b" ? extra : vertical === "ctr" ? extra / 2 : 0;
+    const top = Math.max(0, virtualRect.y - above);
+    const bottom = Math.min(safeBottom, virtualRect.y + virtualRect.height + extra - above);
+    virtualRect = { ...virtualRect, y: top, height: Math.max(virtualRect.height, bottom - top) };
+  }
+  const availableHeight = Math.max(1, virtualRect.height - padding * 2);
+  const heightScale = neededHeight > availableHeight + FIT_TOLERANCE_PX2 ? availableHeight / neededHeight : 1;
+  const renderedFontSize = Math.max(1, fittedFontSize * heightScale * (heightScale < 1 ? 0.95 : 1));
+  const renderedStyle = renderedFontSize === style.fontSize ? style : { ...style, fontSize: renderedFontSize };
+  const rect = toEmuRect(virtualRect);
+  const align = style.textAlign === "center" ? "ctr" : style.textAlign === "right" ? "r" : "l";
+  const inset = Math.max(0, Math.round(padding * EMU_PER_CANVAS_PX));
+  const bodyPr = `<a:bodyPr wrap="square" anchor="${vertical}" vertOverflow="clip" horzOverflow="clip" lIns="${inset}" rIns="${inset}" tIns="${inset}" bIns="${inset}"><a:noAutofit/></a:bodyPr>`;
+  const paragraphs = layer.content.paragraphs || blockGaps ? buildStructuredParagraphs(paragraphSource, renderedStyle, align, {
+    // A list with no marker column of its own hangs its bullets by the
+    // player's list indent.
+    indentPx: listIndentPx ?? renderedStyle.fontSize * LIST_INDENT_EM,
+    spacingScale: renderedStyle.fontSize / fittedFontSize,
+    blockGaps
+  }) : sourceText.split("\n").map((line) => buildLayerTextParagraph(line, renderedStyle, align)).join("");
+  return `<p:sp><p:nvSpPr><p:cNvPr id="${shapeId}" name="${escapeXml(layer.id)}"/><p:cNvSpPr txBox="1"/><p:nvPr/></p:nvSpPr><p:spPr><a:xfrm><a:off x="${rect.x}" y="${rect.y}"/><a:ext cx="${rect.width}" cy="${rect.height}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom>` + fillXml(style.background, style.backgroundOpacity, style.backgroundGradient) + lineXml(style.borderColor, style.borderWidth, style.borderStyle) + `</p:spPr><p:txBody>${bodyPr}<a:lstStyle/>${paragraphs}</p:txBody></p:sp>`;
+}
+var TEXT_PX_TO_CENTIPOINTS = 50;
+var OFFICE_SINGLE_LINE_EM = 1.2;
+var OFFICE_TEXT_RESERVE_EM = 0.3;
+var FIT_TOLERANCE_PX2 = 1;
+function buildStructuredParagraphs(paragraphs, style, align, options) {
+  const plans = planListParagraphs(paragraphs);
+  const gaps = options.blockGaps ? blockGapsEm(paragraphs, style.lineHeight ?? 1.4) : void 0;
+  return paragraphs.map((paragraph, index) => {
+    const gap = gaps?.[index];
+    if (gap === null) return "";
+    return buildLayerTextParagraph(paragraph.text, style, align, {
+      spaceBefore: (gap ?? 0) * style.fontSize + (paragraph.spaceBefore ?? 0) * options.spacingScale,
+      list: plans[index],
+      indentPx: options.indentPx
+    });
+  }).join("");
+}
+function buildLayerTextParagraph(text, style, align, options = {}) {
+  const size = Math.max(100, Math.round(style.fontSize * TEXT_PX_TO_CENTIPOINTS));
+  const color = parseCssColor(style.color, "000000");
+  const typeface = officeTypeface(style.fontFamily, DEFAULT_FONT);
+  const textRunProperties = [
+    `lang="en-US"`,
+    `dirty="0"`,
+    `sz="${size}"`,
+    ...style.fontWeight === "bold" ? ['b="1"'] : [],
+    ...style.fontStyle === "italic" ? ['i="1"'] : []
+  ].join(" ");
+  const lineSpacing = Math.max(
+    1e4,
+    Math.round((style.lineHeight ?? 1.4) / OFFICE_SINGLE_LINE_EM * 1e5)
+  );
+  const lineRuns = (line) => splitIconMarkers2(line).map((run) => {
+    if (run.type === "text") {
+      if (!run.text) return "";
+      return `<a:r><a:rPr ${textRunProperties}>${solidColorXml(color)}<a:latin typeface="${escapeXml(typeface)}"/></a:rPr><a:t>${escapeXml(run.text)}</a:t></a:r>`;
+    }
+    const glyph = fontAwesomeGlyph(run.family, run.name);
+    if (!glyph) return "";
+    const iconTypeface = fontAwesomeFace(run.family).typeface;
+    return `<a:r><a:rPr lang="en-US" dirty="0" sz="${size}">${solidColorXml(color)}<a:latin typeface="${escapeXml(iconTypeface)}"/></a:rPr><a:t>${escapeXml(glyph)}</a:t></a:r>`;
+  }).join("");
+  const runs = text.split("\n").map(lineRuns).join(`<a:br><a:rPr ${textRunProperties}/></a:br>`);
+  const spaceBefore = Math.round((options.spaceBefore ?? 0) * TEXT_PX_TO_CENTIPOINTS);
+  const { attributes, bullet } = options.list ? listParagraphXml(options.list, options.indentPx ?? style.fontSize * LIST_INDENT_EM) : { attributes: "", bullet: "" };
+  return `<a:p><a:pPr${attributes} algn="${align}"><a:lnSpc><a:spcPct val="${lineSpacing}"/></a:lnSpc>` + (spaceBefore > 0 ? `<a:spcBef><a:spcPts val="${spaceBefore}"/></a:spcBef>` : "") + // The bullet takes the text's colour explicitly: renderers that do not
+  // follow the first run fall back to the master's default — black, which
+  // vanishes on a dark deck.
+  (bullet ? `<a:buClr><a:srgbClr val="${color.hex}"/></a:buClr>${bullet}` : "") + `</a:pPr>` + (runs || `<a:r><a:rPr ${textRunProperties}>${solidColorXml(color)}<a:latin typeface="${escapeXml(typeface)}"/></a:rPr><a:t> </a:t></a:r>`) + `</a:p>`;
+}
+
+// src/pptx/masters.ts
+import { relativeLuminance } from "@bendyline/squisq/schemas";
+var GROUP_SHAPE_PROPS = `<p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr/>`;
+function backgroundXml(fill) {
+  return `<p:bg><p:bgPr>${fill}<a:effectLst/></p:bgPr></p:bg>`;
+}
+function paintBackgroundXml(base) {
+  const { fill, fillOpacity, gradient, pattern } = base.content;
+  return backgroundXml(
+    pattern ? patternFillXml(pattern, fill) : fillXml(fill, fillOpacity, gradient)
+  );
+}
+function colorBackgroundXml(hex) {
+  return backgroundXml(`<a:solidFill><a:srgbClr val="${hex}"/></a:solidFill>`);
+}
+function photoBackgroundXml(relId, layer, data) {
+  let crop = "";
+  const size = layer.content.fit === "cover" ? readImageDimensions(data) : null;
+  if (size && size.width > 0 && size.height > 0) {
+    const imageAspect = size.width / size.height;
+    const slideAspect = 16 / 9;
+    if (Math.abs(imageAspect - slideAspect) > 1e-3) {
+      const trim = imageAspect > slideAspect ? 1 - slideAspect / imageAspect : 1 - imageAspect / slideAspect;
+      const edge = Math.round(trim / 2 * 1e5);
+      crop = imageAspect > slideAspect ? `<a:srcRect l="${edge}" r="${edge}"/>` : `<a:srcRect t="${edge}" b="${edge}"/>`;
+    }
+  }
+  return backgroundXml(
+    `<a:blipFill dpi="0" rotWithShape="1"><a:blip r:embed="${relId}"/>${crop}<a:stretch><a:fillRect/></a:stretch></a:blipFill>`
+  );
+}
+function overlayShapesXml(overlays) {
+  return overlays.map((overlay, index) => buildLayerShape(overlay, index + 2)).join("");
+}
+function buildDeckLayoutXml(layout) {
+  return xmlDeclaration() + `<p:sldLayout xmlns:a="${NS_DRAWINGML}" xmlns:r="${NS_R}" xmlns:p="${NS_PML}" preserve="1" userDrawn="1"><p:cSld name="${escapeXml(layout.name)}">` + (layout.base ? paintBackgroundXml(layout.base) : "") + `<p:spTree>${GROUP_SHAPE_PROPS}${overlayShapesXml(layout.overlays)}</p:spTree></p:cSld><p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:sldLayout>`;
+}
+function isDarkTheme(theme) {
+  const background = toOoxmlHex(theme.colors.background, "FFFFFF");
+  const text = toOoxmlHex(theme.colors.text, "000000");
+  return relativeLuminance(`#${background}`) < relativeLuminance(`#${text}`);
+}
+function colorMapXml(dark) {
+  const roles = dark ? 'bg1="dk1" tx1="lt1" bg2="dk2" tx2="lt2"' : 'bg1="lt1" tx1="dk1" bg2="lt2" tx2="dk2"';
+  return `<p:clrMap ${roles} accent1="accent1" accent2="accent2" accent3="accent3" accent4="accent4" accent5="accent5" accent6="accent6" hlink="hlink" folHlink="folHlink"/>`;
+}
+function buildDeckMasterXml(options) {
+  const layoutIds = options.layoutRelIds.map((relId, index) => `<p:sldLayoutId id="${2147483649 + index}" r:id="${relId}"/>`).join("");
+  return xmlDeclaration() + `<p:sldMaster xmlns:a="${NS_DRAWINGML}" xmlns:r="${NS_R}" xmlns:p="${NS_PML}"><p:cSld>${options.backgroundXml}<p:spTree>${GROUP_SHAPE_PROPS}${overlayShapesXml(options.overlays)}</p:spTree></p:cSld>` + colorMapXml(options.dark) + `<p:sldLayoutIdLst>${layoutIds}</p:sldLayoutIdLst></p:sldMaster>`;
+}
+function buildDeckThemeXml(theme) {
+  const c = theme.colors;
+  const hex = (color, fallback) => toOoxmlHex(color, fallback);
+  const dark = isDarkTheme(theme);
+  const background = hex(c.background, "FFFFFF");
+  const text = hex(c.text, "000000");
+  const backgroundLight = hex(c.backgroundLight, background);
+  const textMuted = hex(c.textMuted, text);
+  const accents = [c.primary, c.secondary, c.highlight, c.warning].concat(Object.values(theme.colorSchemes ?? {}).map((scheme) => scheme.accent)).map((color) => color ? toOoxmlHex(color, "") : "").filter((color, index, all) => color && all.indexOf(color) === index);
+  const distinct = accents.length > 0 ? [...accents] : [text];
+  for (let index = accents.length; index < 6; index++) {
+    accents.push(distinct[index % distinct.length]);
+  }
+  const slots = [
+    ["dk1", dark ? background : text],
+    ["lt1", dark ? text : background],
+    ["dk2", dark ? backgroundLight : textMuted],
+    ["lt2", dark ? textMuted : backgroundLight],
+    ...accents.slice(0, 6).map((color, index) => [`accent${index + 1}`, color]),
+    ["hlink", hex(c.highlight || c.primary, "0563C1")],
+    ["folHlink", textMuted]
+  ];
+  const name = escapeXml(theme.name || "Squisq");
+  const titleFont = escapeXml(officeTypeface(theme.typography?.titleFont, DEFAULT_TITLE_FONT));
+  const bodyFont = escapeXml(officeTypeface(theme.typography?.bodyFont, DEFAULT_FONT));
+  const solid = `<a:solidFill><a:schemeClr val="phClr"/></a:solidFill>`;
+  return xmlDeclaration() + `<a:theme xmlns:a="${NS_DRAWINGML}" name="${name}"><a:themeElements><a:clrScheme name="${name}">` + slots.map(([slot, color]) => `<a:${slot}><a:srgbClr val="${color}"/></a:${slot}>`).join("") + `</a:clrScheme><a:fontScheme name="${name}"><a:majorFont><a:latin typeface="${titleFont}"/><a:ea typeface=""/><a:cs typeface=""/></a:majorFont><a:minorFont><a:latin typeface="${bodyFont}"/><a:ea typeface=""/><a:cs typeface=""/></a:minorFont></a:fontScheme><a:fmtScheme name="${name}"><a:fillStyleLst>${solid}${solid}${solid}</a:fillStyleLst><a:lnStyleLst><a:ln w="6350">${solid}</a:ln><a:ln w="6350">${solid}</a:ln><a:ln w="6350">${solid}</a:ln></a:lnStyleLst><a:effectStyleLst><a:effectStyle><a:effectLst/></a:effectStyle><a:effectStyle><a:effectLst/></a:effectStyle><a:effectStyle><a:effectLst/></a:effectStyle></a:effectStyleLst><a:bgFillStyleLst>${solid}${solid}${solid}</a:bgFillStyleLst></a:fmtScheme></a:themeElements></a:theme>`;
+}
+
 // src/pptx/templates.ts
 function buildPresentationXml(slideCount, slideRelIds, slideMasterRelId, _themeRelId, embeddedFonts = []) {
   const sldIdList = [];
@@ -290,9 +1381,10 @@ async function docToPptx(doc, options = {}) {
   const hasLayer = (type) => slideBlocks.some((b) => b.layers?.some((l) => l.type === type));
   const videoPosters = hasLayer("videoEmbed") ? await import("./videoPoster-D7DTZC2L.js") : null;
   const hasSvgImage = slideBlocks.some(
-    (b) => b.layers?.some((l) => l.type === "image" && isSvgImageSource(l.content.src))
+    (b) => b.layers?.some((l) => l.type === "image" && isSvgImageSource2(l.content.src))
   );
   const svgIslandPosters = hasLayer("svg") || hasSvgImage ? await import("./svgIslandPoster-RYA6PDX7.js") : null;
+  const backdrops = planDeckBackdrops(slideBlocks);
   const slideXmls = [];
   const slideContexts = [];
   for (let index = 0; index < slideBlocks.length; index++) {
@@ -307,15 +1399,21 @@ async function docToPptx(doc, options = {}) {
     ctx.diagramImages = effectiveOptions.diagramImages;
     ctx.videoPosters = videoPosters;
     ctx.svgIslandPosters = svgIslandPosters;
-    slideXmls.push(buildLayerSlideXml(slideBlocks[index], ctx));
+    const plan = backdrops.slides[index];
+    ctx.useLayout(plan.layout + 1);
+    slideXmls.push(buildLayerSlideXml(slideBlocks[index], ctx, plan));
     slideContexts.push(ctx);
   }
-  return buildPptxPackage(slideXmls, slideContexts, effectiveOptions);
-}
-function officeTypeface(family, fallback) {
-  const resolved = resolveFontFamily(family, fallback);
-  const first = resolved.split(",")[0]?.trim().replace(/^['"]|['"]$/g, "");
-  return first || fallback;
+  return buildPptxPackage(slideXmls, slideContexts, effectiveOptions, {
+    layoutXmls: backdrops.layouts.map(buildDeckLayoutXml),
+    masterXml: (layoutRelIds) => buildDeckMasterXml({
+      backgroundXml: backdrops.master.base ? paintBackgroundXml(backdrops.master.base) : colorBackgroundXml(style.background),
+      overlays: backdrops.master.overlays,
+      layoutRelIds,
+      dark: isDarkTheme(theme)
+    }),
+    themeXml: buildDeckThemeXml(theme)
+  });
 }
 function resolveSlideStyle(themeId, options, doc) {
   if (!themeId) {
@@ -430,6 +1528,10 @@ var SlideContext = class {
   allocRelId() {
     return this.relIds.alloc();
   }
+  /** Point this slide at slide layout `number` (1-based, as its part is named). */
+  useLayout(number) {
+    this.relationships[0].target = `../slideLayouts/slideLayout${number}.xml`;
+  }
   allocShapeId() {
     return this.nextShapeId++;
   }
@@ -527,31 +1629,46 @@ function buildSlideXml(slide, ctx) {
   const extensionAttrs = transitionXml.includes("p14:") ? ` xmlns:mc="${NS_MC}" xmlns:p14="${NS_PML_2010}" mc:Ignorable="p14"` : "";
   return xmlDeclaration() + `<p:sld xmlns:a="${NS_DRAWINGML}" xmlns:r="${NS_R}" xmlns:p="${NS_PML}"${extensionAttrs}><p:cSld>` + bgXml + `<p:spTree>` + shapes.join("") + `</p:spTree></p:cSld>` + transitionXml + `</p:sld>`;
 }
-function buildLayerSlideXml(block, ctx) {
+function buildLayerSlideXml(block, ctx, plan) {
   const shapes = [
     `<p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr/>`
   ];
-  const textLayerY = (block.layers ?? []).filter((layer) => layer.type === "text").map((layer) => resolvePositionValue(layer.position.y, 1080));
-  for (const layer of block.layers ?? []) {
+  let layers = plan.content;
+  let bgXml = "";
+  if (plan.base?.type === "image") {
+    const photo = plan.base;
+    const data = ctx.images?.get(photo.content.src);
+    if (data) {
+      bgXml = photoBackgroundXml(
+        ctx.addImage(photo.content.src, data, photo.content.alt),
+        photo,
+        data
+      );
+    } else {
+      layers = [photo, ...layers];
+    }
+  } else if (plan.base) {
+    bgXml = paintBackgroundXml(plan.base);
+  }
+  const textScale = isGeometryBoundTemplate(block.template) ? 1 : estimateSlideTextScale(layers);
+  const units = mergeTextFlows(layers, textScale);
+  const textLayerY = units.filter(({ layer }) => layer.type === "text").map(({ layer }) => resolvePositionValue(layer.position.y, 1080));
+  for (const layer of layers) {
     if (layer.type !== "text") continue;
-    for (const run of splitIconMarkers(layer.content.text ?? "")) {
+    for (const run of splitIconMarkers3(layer.content.text ?? "")) {
       if (run.type === "icon") ctx.iconFamilies.add(run.family);
     }
   }
-  for (let index = 0; index < (block.layers?.length ?? 0); index++) {
+  for (let index = 0; index < units.length; index++) {
     if ((index & 31) === 0) ctx.signal?.throwIfAborted();
-    const layer = block.layers[index];
+    const { layer, listIndentPx } = units[index];
     const currentY = layer.type === "text" ? resolvePositionValue(layer.position.y, 1080) : void 0;
     const nextTextY = currentY === void 0 ? void 0 : textLayerY.filter((candidate) => candidate > currentY + 1).sort((a, b) => a - b)[0];
+    const textBottom = nextTextY === void 0 || currentY === void 0 ? void 0 : Math.max(currentY + 1, nextTextY - 8);
     shapes.push(
-      ...convertLayerToShapes(
-        layer,
-        ctx,
-        nextTextY === void 0 || currentY === void 0 ? void 0 : Math.max(currentY + 1, nextTextY - 8)
-      )
+      ...layer.type === "text" ? [buildLayerTextShape(layer, ctx.allocShapeId(), textBottom, listIndentPx, textScale)] : convertLayerToShapes(layer, ctx, textBottom)
     );
   }
-  const bgXml = ctx.style.hasTheme ? `<p:bg><p:bgPr><a:solidFill><a:srgbClr val="${ctx.style.background}"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>` : "";
   const transitionXml = buildTransitionXml(block.transition);
   const extensionAttrs = transitionXml.includes("p14:") ? ` xmlns:mc="${NS_MC}" xmlns:p14="${NS_PML_2010}" mc:Ignorable="p14"` : "";
   return xmlDeclaration() + `<p:sld xmlns:a="${NS_DRAWINGML}" xmlns:r="${NS_R}" xmlns:p="${NS_PML}"${extensionAttrs}><p:cSld>${bgXml}<p:spTree>${shapes.join("")}</p:spTree></p:cSld>` + transitionXml + `</p:sld>`;
@@ -564,7 +1681,7 @@ function convertLayerToShapes(layer, ctx, textBottom) {
       if (layer.content.filter?.type === "noise") return [];
       return [buildLayerShape(layer, ctx.allocShapeId())];
     case "image": {
-      const svg = isSvgImageSource(layer.content.src);
+      const svg = isSvgImageSource2(layer.content.src);
       const area = toEmuRect(resolveLayerRect(layer.position, 1920, 1080));
       const picture = svg ? svgImagePictureShapes(layer, area, ctx) : null;
       if (picture) return picture;
@@ -635,7 +1752,7 @@ function convertLayerToShapes(layer, ctx, textBottom) {
     }
     case "video": {
       const poster = layer.content.posterSrc;
-      const data = poster && !isSvgImageSource(poster) ? ctx.images?.get(poster) : void 0;
+      const data = poster && !isSvgImageSource2(poster) ? ctx.images?.get(poster) : void 0;
       if (poster && data) {
         const relId = ctx.addImage(poster, data, layer.content.alt);
         const embedded = ctx.embeddedImages.find((candidate) => candidate.relId === relId);
@@ -716,127 +1833,6 @@ function convertLayerToShapes(layer, ctx, textBottom) {
     }
   }
 }
-function resolvePositionValue(value, dimension) {
-  if (typeof value === "number") return value;
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (trimmed.endsWith("%")) {
-      const percent = Number.parseFloat(trimmed);
-      if (Number.isFinite(percent)) return percent / 100 * dimension;
-    }
-    const numeric = Number.parseFloat(trimmed);
-    if (Number.isFinite(numeric)) return numeric;
-  }
-  return 0;
-}
-function resolveLayerRect(position, defaultWidth, defaultHeight) {
-  const width = Math.max(
-    1,
-    position.width != null ? resolvePositionValue(position.width, 1920) : defaultWidth
-  );
-  const height = Math.max(
-    1,
-    position.height != null ? resolvePositionValue(position.height, 1080) : defaultHeight
-  );
-  let x = resolvePositionValue(position.x, 1920);
-  let y = resolvePositionValue(position.y, 1080);
-  const anchor = position.anchor ?? "top-left";
-  if (anchor === "center") {
-    x -= width / 2;
-    y -= height / 2;
-  } else {
-    if (anchor.endsWith("right")) x -= width;
-    if (anchor.startsWith("bottom")) y -= height;
-  }
-  const clippedX = Math.min(1919, Math.max(0, x));
-  const clippedY = Math.min(1079, Math.max(0, y));
-  const clippedWidth = Math.max(1, Math.min(width - (clippedX - x), 1920 - clippedX));
-  const clippedHeight = Math.max(1, Math.min(height - (clippedY - y), 1080 - clippedY));
-  return { x: clippedX, y: clippedY, width: clippedWidth, height: clippedHeight };
-}
-function toEmuRect(rect) {
-  return {
-    x: Math.round(rect.x / 1920 * SLIDE_WIDTH),
-    y: Math.round(rect.y / 1080 * SLIDE_HEIGHT),
-    width: Math.max(1, Math.round(rect.width / 1920 * SLIDE_WIDTH)),
-    height: Math.max(1, Math.round(rect.height / 1080 * SLIDE_HEIGHT))
-  };
-}
-function buildLayerTextShape(layer, shapeId, maxBottom) {
-  const sourceText = layer.content.text ?? "";
-  const text = splitIconMarkers(sourceText).map((run) => run.type === "text" ? run.text : "M").join("");
-  const style = layer.content.style;
-  const padding = style.padding ?? 0;
-  const rawLines = text.split("\n");
-  const estimatedWidth = Math.min(
-    1920,
-    Math.max(1, Math.max(...rawLines.map((line) => line.length), 1) * style.fontSize * 0.55)
-  );
-  const boxWidth = layer.position.width != null ? resolvePositionValue(layer.position.width, 1920) : estimatedWidth;
-  const fittedFontSize = rawLines.length === 1 && style.fontSize >= 80 && text.length > 0 ? Math.min(style.fontSize, boxWidth / (text.length * 0.78)) : style.fontSize;
-  const charsPerLine = Math.max(1, Math.floor(boxWidth / Math.max(1, fittedFontSize * 0.58)));
-  const wrappedLineCount = Math.max(
-    1,
-    rawLines.reduce((count, line) => count + Math.max(1, Math.ceil(line.length / charsPerLine)), 0)
-  );
-  const officeFontMetricSlack = fittedFontSize * 0.8;
-  const estimatedHeight = Math.max(
-    fittedFontSize * (style.lineHeight ?? 1.4) * wrappedLineCount + officeFontMetricSlack + padding * 2,
-    fittedFontSize + officeFontMetricSlack + padding * 2
-  );
-  const resolvedRect = resolveLayerRect(layer.position, boxWidth, estimatedHeight);
-  const safeBottom = Math.min(1060, maxBottom ?? 1060);
-  const virtualRect = {
-    ...resolvedRect,
-    y: Math.min(resolvedRect.y, safeBottom - 1),
-    height: Math.max(1, Math.min(resolvedRect.height, safeBottom - resolvedRect.y))
-  };
-  const heightScale = Math.min(1, virtualRect.height / estimatedHeight);
-  const renderedFontSize = Math.max(1, fittedFontSize * heightScale * (heightScale < 1 ? 0.9 : 1));
-  const renderedStyle = renderedFontSize === style.fontSize ? style : { ...style, fontSize: renderedFontSize };
-  const rect = toEmuRect(virtualRect);
-  const align = style.textAlign === "center" ? "ctr" : style.textAlign === "right" ? "r" : "l";
-  const vertical = style.verticalAlign === "bottom" ? "b" : style.verticalAlign === "middle" ? "ctr" : "t";
-  const inset = Math.max(0, Math.round(padding / 1920 * SLIDE_WIDTH));
-  const bodyPr = `<a:bodyPr wrap="square" anchor="${vertical}" vertOverflow="clip" horzOverflow="clip" lIns="${inset}" rIns="${inset}" tIns="${inset}" bIns="${inset}"><a:noAutofit/></a:bodyPr>`;
-  const paragraphs = sourceText.split("\n").map((line) => buildLayerTextParagraph(line, renderedStyle, align)).join("");
-  return `<p:sp><p:nvSpPr><p:cNvPr id="${shapeId}" name="${escapeXml(layer.id)}"/><p:cNvSpPr txBox="1"/><p:nvPr/></p:nvSpPr><p:spPr><a:xfrm><a:off x="${rect.x}" y="${rect.y}"/><a:ext cx="${rect.width}" cy="${rect.height}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom>` + fillXml(style.background, style.backgroundOpacity, style.backgroundGradient) + lineXml(style.borderColor, style.borderWidth, style.borderStyle) + `</p:spPr><p:txBody>${bodyPr}<a:lstStyle/>${paragraphs}</p:txBody></p:sp>`;
-}
-function buildLayerTextParagraph(text, style, align) {
-  const size = Math.max(100, Math.round(style.fontSize * 75));
-  const color = parseCssColor(style.color, "000000");
-  const typeface = officeTypeface(style.fontFamily, DEFAULT_FONT);
-  const textRunProperties = [
-    `lang="en-US"`,
-    `dirty="0"`,
-    `sz="${size}"`,
-    ...style.fontWeight === "bold" ? ['b="1"'] : [],
-    ...style.fontStyle === "italic" ? ['i="1"'] : []
-  ].join(" ");
-  const lineSpacing = Math.max(1e4, Math.round((style.lineHeight ?? 1.4) * 1e5));
-  const runs = splitIconMarkers(text).map((run) => {
-    if (run.type === "text") {
-      if (!run.text) return "";
-      return `<a:r><a:rPr ${textRunProperties}>${solidColorXml(color)}<a:latin typeface="${escapeXml(typeface)}"/></a:rPr><a:t>${escapeXml(run.text)}</a:t></a:r>`;
-    }
-    const glyph = fontAwesomeGlyph(run.family, run.name);
-    if (!glyph) return "";
-    const iconTypeface = fontAwesomeFace(run.family).typeface;
-    return `<a:r><a:rPr lang="en-US" dirty="0" sz="${size}">${solidColorXml(color)}<a:latin typeface="${escapeXml(iconTypeface)}"/></a:rPr><a:t>${escapeXml(glyph)}</a:t></a:r>`;
-  }).join("");
-  return `<a:p><a:pPr algn="${align}"><a:lnSpc><a:spcPct val="${lineSpacing}"/></a:lnSpc></a:pPr>` + (runs || `<a:r><a:rPr ${textRunProperties}>${solidColorXml(color)}<a:latin typeface="${escapeXml(typeface)}"/></a:rPr><a:t> </a:t></a:r>`) + `</a:p>`;
-}
-function buildLayerShape(layer, shapeId) {
-  const rect = toEmuRect(resolveLayerRect(layer.position, 100, 100));
-  const geometry = layer.content.shape === "circle" ? "ellipse" : layer.content.shape === "line" ? "line" : layer.content.borderRadius ? "roundRect" : "rect";
-  const fill = layer.content.shape === "line" ? "<a:noFill/>" : fillXml(layer.content.fill, layer.content.fillOpacity, layer.content.gradient);
-  const stroke = lineXml(
-    layer.content.stroke ?? (layer.content.shape === "line" ? "#ffffff" : void 0),
-    layer.content.strokeWidth ?? (layer.content.shape === "line" ? 2 : void 0),
-    layer.content.borderStyle
-  );
-  return `<p:sp><p:nvSpPr><p:cNvPr id="${shapeId}" name="${escapeXml(layer.id)}"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr><p:spPr><a:xfrm><a:off x="${rect.x}" y="${rect.y}"/><a:ext cx="${rect.width}" cy="${rect.height}"/></a:xfrm><a:prstGeom prst="${geometry}"><a:avLst/></a:prstGeom>` + fill + stroke + `</p:spPr></p:sp>`;
-}
 function buildTableLayerShapes(layer, ctx) {
   const visibleBodyRows = layer.content.maxVisibleRows ? layer.content.rows.slice(0, Math.max(1, Math.floor(layer.content.maxVisibleRows))) : layer.content.rows;
   const rows = [layer.content.headers, ...visibleBodyRows];
@@ -928,7 +1924,7 @@ function buildPathLayerShapes(layer, ctx) {
   const flipH = x2 < x1 ? ' flipH="1"' : "";
   const flipV = y2 < y1 ? ' flipV="1"' : "";
   const stroke = parseCssColor(layer.content.stroke, "FFFFFF");
-  const width = Math.max(1, Math.round((layer.content.strokeWidth ?? 2) * 9525));
+  const width = Math.max(1, Math.round((layer.content.strokeWidth ?? 2) * EMU_PER_CANVAS_PX));
   const head = markerXml("headEnd", layer.content.startMarker);
   const tail = markerXml("tailEnd", layer.content.endMarker);
   const dash = dashXml(layer.content.borderStyle, layer.content.dasharray);
@@ -956,79 +1952,6 @@ function textLayerForPlaceholder(position, text, ctx) {
     }
   };
 }
-function parseCssColor(color, fallback) {
-  if (!color) return { hex: toOoxmlHex(fallback), alpha: 1e5 };
-  const trimmed = color.trim();
-  if (trimmed === "transparent" || trimmed === "none") return { hex: "000000", alpha: 0 };
-  const hexMatch = /^#?([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(trimmed);
-  if (hexMatch) {
-    const raw = hexMatch[1];
-    const expanded = raw.length === 3 ? raw.split("").map((char) => char + char).join("") : raw;
-    const alpha = expanded.length === 8 ? Math.round(Number.parseInt(expanded.slice(6, 8), 16) / 255 * 1e5) : 1e5;
-    return { hex: expanded.slice(0, 6).toUpperCase(), alpha };
-  }
-  const rgbMatch = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)$/i.exec(trimmed);
-  if (rgbMatch) {
-    const channel = (value) => Math.max(0, Math.min(255, Math.round(Number(value)))).toString(16).padStart(2, "0");
-    const alpha = rgbMatch[4] ? Math.round(Math.max(0, Math.min(1, Number(rgbMatch[4]))) * 1e5) : 1e5;
-    return {
-      hex: `${channel(rgbMatch[1])}${channel(rgbMatch[2])}${channel(rgbMatch[3])}`.toUpperCase(),
-      alpha
-    };
-  }
-  const named = {
-    black: "000000",
-    white: "FFFFFF",
-    red: "FF0000",
-    blue: "0000FF",
-    green: "008000",
-    gray: "808080",
-    grey: "808080"
-  };
-  return { hex: named[trimmed.toLowerCase()] ?? toOoxmlHex(fallback), alpha: 1e5 };
-}
-function solidColorXml(color) {
-  const alpha = color.alpha < 1e5 ? `<a:alpha val="${color.alpha}"/>` : "";
-  return `<a:solidFill><a:srgbClr val="${color.hex}">${alpha}</a:srgbClr></a:solidFill>`;
-}
-function fillXml(fill, opacity, gradient) {
-  if (gradient) return gradientFillXml(gradient.from, gradient.to, gradient.angle ?? 0, opacity);
-  if (!fill || fill === "none" || fill === "transparent") return "<a:noFill/>";
-  if (fill.includes("gradient(")) {
-    const colors = fill.match(/#[0-9a-f]{3,8}|rgba?\([^)]*\)/gi) ?? [];
-    if (colors.length >= 2) {
-      const angle = Number.parseFloat(
-        /(?:linear-gradient\()\s*([\d.-]+)deg/i.exec(fill)?.[1] ?? "0"
-      );
-      return gradientFillXml(colors[0], colors[colors.length - 1], angle, opacity);
-    }
-  }
-  const color = parseCssColor(fill, "000000");
-  if (opacity !== void 0)
-    color.alpha = Math.round(color.alpha * Math.max(0, Math.min(1, opacity)));
-  return solidColorXml(color);
-}
-function gradientFillXml(from, to, angle, opacity) {
-  const first = parseCssColor(from, "000000");
-  const second = parseCssColor(to, first.hex);
-  if (opacity !== void 0) {
-    const factor = Math.max(0, Math.min(1, opacity));
-    first.alpha = Math.round(first.alpha * factor);
-    second.alpha = Math.round(second.alpha * factor);
-  }
-  const ooxmlAngle = Math.round(((90 - angle) % 360 + 360) % 360 * 6e4);
-  return `<a:gradFill rotWithShape="1"><a:gsLst><a:gs pos="0"><a:srgbClr val="${first.hex}">${first.alpha < 1e5 ? `<a:alpha val="${first.alpha}"/>` : ""}</a:srgbClr></a:gs><a:gs pos="100000"><a:srgbClr val="${second.hex}">${second.alpha < 1e5 ? `<a:alpha val="${second.alpha}"/>` : ""}</a:srgbClr></a:gs></a:gsLst><a:lin ang="${ooxmlAngle}" scaled="1"/></a:gradFill>`;
-}
-function lineXml(color, widthPx, borderStyle) {
-  if (!color || !widthPx || widthPx <= 0) return "<a:ln><a:noFill/></a:ln>";
-  const width = Math.max(1, Math.round(widthPx * 9525));
-  return `<a:ln w="${width}">${solidColorXml(parseCssColor(color, "000000"))}${dashXml(borderStyle)}</a:ln>`;
-}
-function dashXml(style, dasharray) {
-  if (style === "dashed" || dasharray && dasharray !== "none") return '<a:prstDash val="dash"/>';
-  if (style === "dotted") return '<a:prstDash val="dot"/>';
-  return "";
-}
 function markerXml(tag, marker) {
   if (!marker || marker === "none") return "";
   const type = marker === "arrow" ? "triangle" : marker === "open" ? "arrow" : marker === "diamond" ? "diamond" : marker === "circle" ? "oval" : "square";
@@ -1285,7 +2208,7 @@ function isImageOnlyParagraph(node) {
 function convertParagraph(node, ctx) {
   const soloImage = isImageOnlyParagraph(node);
   if (soloImage && ctx.images) {
-    const data = isSvgImageSource(soloImage.url) ? void 0 : ctx.images.get(soloImage.url);
+    const data = isSvgImageSource2(soloImage.url) ? void 0 : ctx.images.get(soloImage.url);
     if (data) {
       ctx.addImage(soloImage.url, data, soloImage.alt || "");
       return "";
@@ -1437,7 +2360,7 @@ function makeHyperlinkRun(text, rId, format) {
 }
 function convertImage(node, format, ctx) {
   if (ctx.images) {
-    const data = isSvgImageSource(node.url) ? void 0 : ctx.images.get(node.url);
+    const data = isSvgImageSource2(node.url) ? void 0 : ctx.images.get(node.url);
     if (data) {
       ctx.addImage(node.url, data, node.alt || "");
       return "";
@@ -1446,13 +2369,17 @@ function convertImage(node, format, ctx) {
   const alt = node.alt || node.url;
   return makeRun(`[Image: ${alt}]`, { ...format, italic: true }, ctx.style);
 }
-async function buildPptxPackage(slideXmls, slideContexts, options) {
+var SEMANTIC_DECK_STRUCTURE = {
+  layoutXmls: [buildSlideLayoutXml("")],
+  masterXml: ([layoutRelId]) => buildSlideMasterXml(layoutRelId),
+  themeXml: buildThemeXml()
+};
+async function buildPptxPackage(slideXmls, slideContexts, options, structure = SEMANTIC_DECK_STRUCTURE) {
   const pkg = createPackage();
   const slideCount = slideXmls.length;
   const relIds = new RelIdAllocator();
   const PRESENTATION_PART = "ppt/presentation.xml";
   const SLIDE_MASTER_PART = "ppt/slideMasters/slideMaster1.xml";
-  const SLIDE_LAYOUT_PART = "ppt/slideLayouts/slideLayout1.xml";
   const slideRelIds = [];
   for (let i = 0; i < slideCount; i++) {
     slideRelIds.push(relIds.alloc(PRESENTATION_PART));
@@ -1491,30 +2418,36 @@ async function buildPptxPackage(slideXmls, slideContexts, options) {
       pkg.addBinaryPart(img.mediaPath, img.data, img.contentType);
     }
   }
-  const layoutMasterRelId = relIds.alloc(SLIDE_LAYOUT_PART);
-  const slideLayoutXml = buildSlideLayoutXml(layoutMasterRelId);
-  pkg.addPart(SLIDE_LAYOUT_PART, slideLayoutXml, CONTENT_TYPE_PPTX_SLIDE_LAYOUT);
-  pkg.addRelationship(SLIDE_LAYOUT_PART, {
-    id: layoutMasterRelId,
-    type: REL_SLIDE_MASTER,
-    target: "../slideMasters/slideMaster1.xml"
+  const masterLayoutRelIds = [];
+  structure.layoutXmls.forEach((layoutXml, index) => {
+    const layoutPart = `ppt/slideLayouts/slideLayout${index + 1}.xml`;
+    const layoutMasterRelId = relIds.alloc(layoutPart);
+    pkg.addPart(layoutPart, layoutXml, CONTENT_TYPE_PPTX_SLIDE_LAYOUT);
+    pkg.addRelationship(layoutPart, {
+      id: layoutMasterRelId,
+      type: REL_SLIDE_MASTER,
+      target: "../slideMasters/slideMaster1.xml"
+    });
+    const masterLayoutRelId = relIds.alloc(SLIDE_MASTER_PART);
+    masterLayoutRelIds.push(masterLayoutRelId);
+    pkg.addRelationship(SLIDE_MASTER_PART, {
+      id: masterLayoutRelId,
+      type: REL_SLIDE_LAYOUT,
+      target: `../slideLayouts/slideLayout${index + 1}.xml`
+    });
   });
-  const masterLayoutRelId = relIds.alloc(SLIDE_MASTER_PART);
   const masterThemeRelId = relIds.alloc(SLIDE_MASTER_PART);
-  const slideMasterXml = buildSlideMasterXml(masterLayoutRelId);
-  pkg.addPart(SLIDE_MASTER_PART, slideMasterXml, CONTENT_TYPE_PPTX_SLIDE_MASTER);
-  pkg.addRelationship(SLIDE_MASTER_PART, {
-    id: masterLayoutRelId,
-    type: REL_SLIDE_LAYOUT,
-    target: "../slideLayouts/slideLayout1.xml"
-  });
+  pkg.addPart(
+    SLIDE_MASTER_PART,
+    structure.masterXml(masterLayoutRelIds),
+    CONTENT_TYPE_PPTX_SLIDE_MASTER
+  );
   pkg.addRelationship(SLIDE_MASTER_PART, {
     id: masterThemeRelId,
     type: REL_THEME,
     target: "../theme/theme1.xml"
   });
-  const themeXml = buildThemeXml();
-  pkg.addPart("ppt/theme/theme1.xml", themeXml, CONTENT_TYPE_PPTX_THEME);
+  pkg.addPart("ppt/theme/theme1.xml", structure.themeXml, CONTENT_TYPE_PPTX_THEME);
   pkg.addRelationship("", {
     id: "rId1",
     type: REL_OFFICE_DOCUMENT,