@openpresentation/opf 0.11.3 → 0.12.0

package/dist/chunk-BVLWFMDX.js

@@ -1,1812 +0,0 @@
-// src/table.ts
-var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
-function tableGrid(value, path = "table") {
-  const table = record(value), hasHeaders = Array.isArray(table.columns) && table.columns.length > 0;
-  const values = [...hasHeaders ? [table.columns] : [], ...Array.isArray(table.rows) ? table.rows : []];
-  const columnCount = values.reduce((count, row) => Math.max(count, Array.isArray(row) ? row.length : 0), 1), rowCount = values.length;
-  const owners = Array.from({ length: rowCount }, () => Array(columnCount));
-  const rows2 = Array.from({ length: rowCount }, () => []), issues = [];
-  const location = (r, c) => `${path}.${hasHeaders && r === 0 ? "columns" : `rows.${r - Number(hasHeaders)}`}.${c}`;
-  for (let r = 0; r < rowCount; r++) for (let c = 0; c < columnCount; c++) {
-    const input = values[r]?.[c], cellPath = location(r, c), existing = owners[r][c];
-    if (existing) {
-      if (input !== null) issues.push({ path: cellPath, message: "A position covered by a spanning cell must explicitly contain null; content cannot be hidden." });
-      continue;
-    }
-    const object = record(input), styled = Object.hasOwn(object, "value");
-    const rowSpan = styled ? object.rowSpan ?? 1 : 1, colSpan = styled ? object.colSpan ?? 1 : 1;
-    if (!Number.isSafeInteger(rowSpan) || !Number.isSafeInteger(colSpan) || rowSpan < 1 || colSpan < 1 || r + rowSpan > rowCount || c + colSpan > columnCount || hasHeaders && r === 0 && rowSpan > 1) {
-      issues.push({ path: cellPath, message: "Cell spans must be positive integers within the table grid and cannot cross from headers into body rows." });
-      continue;
-    }
-    const cell = { input, value: styled ? object.value : input, style: styled ? record(object.style) : {}, row: r, column: c, rowSpan, colSpan, header: hasHeaders && r === 0, path: cellPath, valuePath: styled ? cellPath + ".value" : cellPath };
-    rows2[r].push(cell);
-    for (let y = r; y < r + rowSpan; y++) for (let x = c; x < c + colSpan; x++) {
-      if (owners[y][x]) issues.push({ path: cellPath, message: "Cell spans cannot overlap another spanning cell." });
-      else owners[y][x] = cell;
-    }
-  }
-  return { rows: rows2, columnCount, rowCount, hasHeaders, owners, issues };
-}
-function tableRowBoundaries(value) {
-  const grid = tableGrid(value), offset = Number(grid.hasHeaders), count = grid.rowCount - offset;
-  const allowed = new Set(Array.from({ length: count + 1 }, (_, i) => i));
-  for (const row of grid.rows) for (const cell of row) if (!cell.header) for (let r = 1; r < cell.rowSpan; r++) allowed.delete(cell.row - offset + r);
-  return [...allowed];
-}
-
-// src/furniture-fields.ts
-var DEFAULT_FURNITURE_DATE_FORMAT = "M/d/yyyy";
-var DEFAULT_SLIDE_NUMBER_FORMAT = "{current}";
-var months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
-var weekdays = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
-var tokenWidths = { y: [1, 2, 4], M: [1, 2, 3, 4], d: [1, 2], E: [1, 2, 3, 4] };
-function parseFurnitureDateFormat(pattern) {
-  if (!pattern) return "dateFormat must not be empty.";
-  const tokens = [];
-  const literal = (text) => {
-    const last = tokens[tokens.length - 1];
-    if (last?.kind === "literal") last.text += text;
-    else tokens.push({ kind: "literal", text });
-  };
-  for (let index = 0; index < pattern.length; ) {
-    const character = pattern.charAt(index);
-    if (character === "'") {
-      if (pattern[index + 1] === "'") {
-        literal("'");
-        index += 2;
-        continue;
-      }
-      let end = index + 1, text = "";
-      for (; ; ) {
-        if (end >= pattern.length) return "dateFormat has an unterminated quoted literal.";
-        if (pattern[end] === "'") {
-          if (pattern[end + 1] === "'") {
-            text += "'";
-            end += 2;
-            continue;
-          }
-          break;
-        }
-        text += pattern[end];
-        end++;
-      }
-      literal(text);
-      index = end + 1;
-      continue;
-    }
-    if (/[A-Za-z]/.test(character)) {
-      let end = index;
-      while (pattern[end] === character) end++;
-      const width = end - index;
-      if (!tokenWidths[character]?.includes(width)) return `dateFormat token '${pattern.slice(index, end)}' is not supported; use yyyy, yy, MMMM, MMM, MM, M, dd, d, EEEE or EEE, and quote literal letters.`;
-      tokens.push({ kind: "field", letter: character, width });
-      index = end;
-      continue;
-    }
-    literal(character);
-    index++;
-  }
-  return tokens;
-}
-function parseIsoDate(value) {
-  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
-  if (!match) return null;
-  const year = Number(match[1]), month = Number(match[2]), day = Number(match[3]);
-  const date = new Date(Date.UTC(2e3, month - 1, day));
-  date.setUTCFullYear(year);
-  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) return null;
-  return { year, month, day };
-}
-function formatFurnitureDate(iso, pattern) {
-  const date = parseIsoDate(iso);
-  if (!date) return { error: `'${iso}' is not an ISO YYYY-MM-DD calendar date.` };
-  const tokens = parseFurnitureDateFormat(pattern);
-  if (typeof tokens === "string") return { error: tokens };
-  const utc = new Date(Date.UTC(2e3, date.month - 1, date.day));
-  utc.setUTCFullYear(date.year);
-  const pad = (value, width) => String(value).padStart(width, "0");
-  let text = "";
-  for (const token of tokens) {
-    if (token.kind === "literal") {
-      text += token.text;
-      continue;
-    }
-    const { letter, width } = token;
-    if (letter === "y") text += width === 2 ? pad(date.year % 100, 2) : width === 4 ? pad(date.year, 4) : String(date.year);
-    else if (letter === "M") {
-      const name = months[date.month - 1] ?? "";
-      text += width >= 3 ? width === 4 ? name : name.slice(0, 3) : pad(date.month, width);
-    } else if (letter === "d") text += pad(date.day, width);
-    else {
-      const name = weekdays[utc.getUTCDay()] ?? "";
-      text += width === 4 ? name : name.slice(0, 3);
-    }
-  }
-  return { text };
-}
-function formatSlideNumber(format, current, total) {
-  if (!format.includes("{current}")) return { error: "slideNumberFormat must contain {current}." };
-  if (format.includes("{total}") && total === void 0) return { error: "slideNumberFormat uses {total}, which needs the rendered slide count." };
-  let text = "";
-  const fields2 = [];
-  for (const piece of format.split(/(\{current\}|\{total\})/)) {
-    if (piece === "{current}") {
-      const value = String(current);
-      fields2.push({ type: "slideNumber", start: text.length, end: text.length + value.length });
-      text += value;
-    } else if (piece === "{total}") text += String(total);
-    else text += piece;
-  }
-  return { text, fields: fields2 };
-}
-
-// src/color.ts
-var schemeColorSlots = /* @__PURE__ */ new Set([
-  "accent1",
-  "accent2",
-  "accent3",
-  "accent4",
-  "accent5",
-  "accent6",
-  "dark1",
-  "dark2",
-  "light1",
-  "light2",
-  "hyperlink",
-  "followedHyperlink"
-]);
-var schemeColorRoles = /* @__PURE__ */ new Set([
-  "primary",
-  "secondary",
-  "accent",
-  "background",
-  "surface",
-  "text",
-  "textSecondary"
-]);
-var defaultRoleSlots = {
-  primary: "accent1",
-  secondary: "accent2",
-  accent: "accent3",
-  background: "light1",
-  surface: "light2",
-  text: "dark1",
-  textSecondary: "dark2"
-};
-function normalizeHexColor(value) {
-  if (typeof value !== "string") return void 0;
-  let hex = value.trim();
-  if (/^#[0-9a-f]{3}$/i.test(hex)) hex = `#${[...hex.slice(1)].map((char) => char + char).join("")}`;
-  if (/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(hex)) return hex.length === 9 ? `#${hex.slice(1, 7).toUpperCase()}` : hex.toUpperCase();
-  return void 0;
-}
-function schemeSlot(colorScheme, slot, fallback) {
-  return normalizeHexColor(colorScheme[slot]) ?? fallback;
-}
-function resolveVariable(variables, id, fallback) {
-  const entry = variables[id];
-  if (typeof entry === "string") return normalizeHexColor(entry) ?? fallback;
-  if (entry && typeof entry === "object" && entry.type === "color") {
-    return normalizeHexColor(entry.value) ?? fallback;
-  }
-  return fallback;
-}
-function resolveColorRef(reference, options) {
-  const { colorScheme, roles, variables = {}, fallback } = options;
-  const literal = normalizeHexColor(reference);
-  if (literal) return literal;
-  if (reference.startsWith("var:")) {
-    const id = reference.slice("var:".length);
-    if (/^[a-z][a-z0-9-]*$/.test(id)) return resolveVariable(variables, id, fallback);
-    return fallback;
-  }
-  if (schemeColorRoles.has(reference)) {
-    const roleKey = reference;
-    const fromRoles = roles?.[roleKey];
-    if (fromRoles) return normalizeHexColor(fromRoles) ?? fallback;
-    const fromScheme = normalizeHexColor(colorScheme[reference]);
-    if (fromScheme) return fromScheme;
-    const slot = defaultRoleSlots[reference];
-    return slot ? schemeSlot(colorScheme, slot, fallback) : fallback;
-  }
-  if (schemeColorSlots.has(reference)) return schemeSlot(colorScheme, reference, fallback);
-  return fallback;
-}
-function luminance(value) {
-  if (typeof value !== "string") return void 0;
-  let hex = value.trim();
-  if (/^#[0-9a-f]{3}$/i.test(hex)) hex = `#${[...hex.slice(1)].map((c) => c + c).join("")}`;
-  if (/^#[0-9a-f]{6}ff$/i.test(hex)) hex = hex.slice(0, 7);
-  if (!/^#[0-9a-f]{6}$/i.test(hex)) return void 0;
-  return [0.2126, 0.7152, 0.0722].reduce((sum, weight, index) => {
-    const offset = index * 2 + 1;
-    const n = Number.parseInt(hex.slice(offset, offset + 2), 16) / 255;
-    return sum + weight * (n <= 0.04045 ? n / 12.92 : ((n + 0.055) / 1.055) ** 2.4);
-  }, 0);
-}
-function colorContrast(foreground, background) {
-  const a = luminance(foreground), b = luminance(background);
-  return a === void 0 || b === void 0 ? void 0 : (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
-}
-function textColorForFill(fill, preferred) {
-  const background = luminance(fill), contrast = colorContrast(preferred, fill);
-  if (background === void 0 || contrast === void 0 || contrast >= 4.5) return preferred;
-  return (background + 0.05) / 0.05 >= 1.05 / (background + 0.05) ? "#000000" : "#FFFFFF";
-}
-function chartColorForFill(fill, preferred) {
-  const contrast = colorContrast(preferred, fill);
-  if (contrast === void 0 || contrast >= 3) return preferred;
-  let hex = preferred.trim();
-  if (hex.length === 4) hex = `#${[...hex.slice(1)].map((c) => c + c).join("")}`;
-  const channels = [1, 3, 5].map((offset) => Number.parseInt(hex.slice(offset, offset + 2), 16));
-  for (let step = 1; step <= 255; step++) {
-    const candidates = [0, 255].map((target) => {
-      const color = `#${channels.map((channel) => Math.round(channel + (target - channel) * step / 255).toString(16).padStart(2, "0")).join("")}`.toUpperCase();
-      return { color, contrast: colorContrast(color, fill) ?? 0 };
-    }).sort((a, b) => b.contrast - a.contrast);
-    const best = candidates[0];
-    if (best && best.contrast >= 3) return best.color;
-  }
-  return textColorForFill(fill, preferred);
-}
-
-// src/composition.ts
-var MAX_COMPOSITION_DEPTH = 32;
-var FALLBACK_CODE_FAMILY = "Roboto Mono";
-var DEFAULT_FONT_SCHEME = "aptos";
-var DEFAULT_FONT_FAMILIES = { heading: "Aptos Display", body: "Aptos" };
-function resolveFontSchemeReference(reference, lookup, path = "design.fontScheme") {
-  const overrides = typeof reference === "object" && reference !== null && !Array.isArray(reference) ? reference : void 0;
-  const id = typeof reference === "string" ? reference : typeof overrides?.id === "string" ? overrides.id : void 0;
-  const found = id === void 0 ? void 0 : lookup(id);
-  const base = record2(found ?? lookup(DEFAULT_FONT_SCHEME));
-  const scheme = overrides ? { ...base, ...overrides } : { ...base };
-  if (id === void 0 || found !== void 0) return { scheme };
-  return { scheme, diagnostic: { code: "unresolved-font-scheme", path, id, fallback: DEFAULT_FONT_SCHEME, message: `Font scheme '${id}' is not in the inline or bundled catalogs; using the default font scheme '${DEFAULT_FONT_SCHEME}'.` } };
-}
-function resolveFontFamilies(input) {
-  const scheme = record2(input);
-  const family = (value) => typeof value === "string" ? value : record2(value).family;
-  return {
-    heading: family(scheme.heading) ?? scheme.major ?? scheme.minor ?? DEFAULT_FONT_FAMILIES.heading,
-    body: family(scheme.body) ?? scheme.minor ?? scheme.major ?? DEFAULT_FONT_FAMILIES.body,
-    code: family(scheme.code) ?? FALLBACK_CODE_FAMILY
-  };
-}
-function resolveTextStyle(style, measurement) {
-  return measurement?.resolveStyle ? measurement.resolveStyle(style) : style;
-}
-function textWidthMeasurer(style, measurement) {
-  if (!measurement) return measureText;
-  return (text, size) => {
-    const width = measurement.measure(text, size, style);
-    if (!Number.isFinite(width) || width < 0) throw new RangeError("Text measurement must return a finite, nonnegative width.");
-    return width;
-  };
-}
-function measureTextOutline(text, fontSize, style, measurement) {
-  if (measurement?.outlineBounds === void 0) return void 0;
-  if (typeof measurement.outlineBounds !== "function") throw new TypeError("Text outline provider must be a function.");
-  const bounds = measurement.outlineBounds(text, fontSize, style);
-  if (bounds === null) return null;
-  if (!bounds || ![bounds.x, bounds.y, bounds.width, bounds.height].every(Number.isFinite) || bounds.width < 0 || bounds.height < 0) {
-    throw new RangeError("Text outline measurement must return null or finite bounds with nonnegative dimensions.");
-  }
-  return { x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height };
-}
-function placeTextLines(lines, box, alignment = "left", rasterPadding = 0) {
-  if (!Array.isArray(lines) || !box || ![box.x, box.y, box.width, box.height, rasterPadding].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || rasterPadding < 0 || !["left", "center", "right"].includes(alignment)) throw new RangeError("Text placement requires lines, finite positive dimensions, nonnegative padding and a valid alignment.");
-  const factor = alignment === "right" ? 1 : alignment === "center" ? 0.5 : 0, placed = [];
-  let shift = 0, bottom = box.y, height = 0, overflow = false;
-  for (const line of lines) {
-    if (!line || ![line.width, line.y, line.baseline, line.height].every(Number.isFinite) || line.width < 0 || line.height <= 0 || line.y < 0 || line.baseline < line.y) throw new RangeError("Text lines require finite coordinates, nonnegative advances and a baseline at or below their top.");
-    const ink = line.outline;
-    if (ink !== null && (!ink || ![ink.x, ink.y, ink.width, ink.height].every(Number.isFinite) || ink.width < 0 || ink.height < 0)) throw new RangeError("Text outlines must be null or finite coordinates with nonnegative dimensions.");
-    let x = box.x + (box.width - line.width) * factor;
-    if (ink) {
-      const low = box.x + rasterPadding - ink.x, high = box.x + box.width - rasterPadding - ink.x - ink.width;
-      if (low > high + 0.01) overflow = true;
-      else x = Math.max(low, Math.min(x, high));
-      shift += Math.max(0, bottom + rasterPadding - (box.y + line.baseline + shift + ink.y));
-    }
-    const y = box.y + line.y + shift, baseline = box.y + line.baseline + shift;
-    const outline = ink ? { ...ink, x: x + ink.x, y: baseline + ink.y } : null;
-    if (outline) bottom = outline.y + outline.height + rasterPadding;
-    height = Math.max(height, y + line.height - box.y, outline ? bottom - box.y : 0);
-    if (line.width > box.width + 0.01 || height > box.height + 0.01) overflow = true;
-    placed.push({ x, y, baseline, height: line.height, width: line.width, outline });
-  }
-  return { alignment, rasterPadding, lines: placed, height, overflow };
-}
-function translateTextFit(fit, dy) {
-  if (!dy || !fit.placement) return fit;
-  return {
-    ...fit,
-    placement: {
-      ...fit.placement,
-      lines: fit.placement.lines.map((line) => ({
-        ...line,
-        y: line.y + dy,
-        baseline: line.baseline + dy,
-        outline: line.outline ? { ...line.outline, y: line.outline.y + dy } : line.outline
-      }))
-    }
-  };
-}
-var OPFCompositionError = class extends Error {
-  constructor(diagnostics, explanation) {
-    super("Slide content does not fit its composition.");
-    this.diagnostics = diagnostics;
-    this.name = "OPFCompositionError";
-    if (explanation) this.explanation = explanation;
-  }
-  diagnostics;
-  code = "layout-overflow";
-  explanation;
-};
-var fields = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
-var headings = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
-var COVER_LAYOUT_IDS = /* @__PURE__ */ new Set(["title", "title-subtitle"]);
-var rows = ["top", "middle", "bottom"];
-var columns = ["left", "center", "right"];
-var record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
-var kind = (field) => field === "items" ? "list" : field === "bullets" ? "text" : field;
-var round = (value) => Math.round(value * 1e6) / 1e6 || value;
-var SLIDE_IMAGE_POSITIONS = ["background", "top", "bottom", "left", "right"];
-var SLIDE_IMAGE_BAND = 0.5;
-var assetSource = (value) => typeof value === "string" ? value : record2(value).src;
-var finite = (value, min, max) => typeof value === "number" && Number.isFinite(value) && value >= min && value <= max ? value : void 0;
-var pathNumber = (value) => String(round(value));
-var SLIDE_IMAGE_SHAPES = { rectangle: "rect", rounded: "roundRect", circle: "ellipse", hexagon: "hexagon" };
-function slideImageShape(kind2, box, cornerRadius = 1 / 6) {
-  const { x, y, width: w, height: h } = box, r = x + w, b = y + h, ss = Math.min(w, h), n = pathNumber;
-  const rect = `M${n(x)} ${n(y)}H${n(r)}V${n(b)}H${n(x)}Z`;
-  if (kind2 === "rounded") {
-    const adj = Math.round(Math.min(0.5, Math.max(0, cornerRadius)) * 1e5), radius = ss * adj / 1e5;
-    const path = radius <= 0 ? rect : `M${n(x)} ${n(y + radius)}A${n(radius)} ${n(radius)} 0 0 1 ${n(x + radius)} ${n(y)}H${n(r - radius)}A${n(radius)} ${n(radius)} 0 0 1 ${n(r)} ${n(y + radius)}V${n(b - radius)}A${n(radius)} ${n(radius)} 0 0 1 ${n(r - radius)} ${n(b)}H${n(x + radius)}A${n(radius)} ${n(radius)} 0 0 1 ${n(x)} ${n(b - radius)}Z`;
-    return { kind: kind2, preset: "roundRect", adjust: { adj }, path };
-  }
-  if (kind2 === "circle") {
-    const cy = y + h / 2;
-    return { kind: kind2, preset: "ellipse", adjust: {}, path: `M${n(x)} ${n(cy)}A${n(w / 2)} ${n(h / 2)} 0 1 1 ${n(r)} ${n(cy)}A${n(w / 2)} ${n(h / 2)} 0 1 1 ${n(x)} ${n(cy)}Z` };
-  }
-  if (kind2 === "hexagon") {
-    const adj = 25e3, vf = 115470, a = Math.min(Math.max(adj, 0), 5e4 * w / ss);
-    const x1 = ss * a / 1e5, x2 = r - x1, vc = y + h / 2, dy1 = h / 2 * vf / 1e5 * Math.sin(Math.PI / 3);
-    return { kind: kind2, preset: "hexagon", adjust: { adj, vf }, path: `M${n(x)} ${n(vc)}L${n(x + x1)} ${n(vc - dy1)}L${n(x2)} ${n(vc - dy1)}L${n(r)} ${n(vc)}L${n(x2)} ${n(vc + dy1)}L${n(x + x1)} ${n(vc + dy1)}Z` };
-  }
-  return { kind: "rectangle", preset: "rect", adjust: {}, path: rect };
-}
-function resolveSlideImage(slide, layout, presentation, width, height, path, padding, scale, diagnostics) {
-  const own = record2(slide.design), deck = record2(record2(presentation).design);
-  const local = own.slideImage !== void 0;
-  const configured = local ? own.slideImage : deck.slideImage;
-  if (!configured || typeof configured !== "object" && typeof configured !== "string") return void 0;
-  const treatment = typeof configured === "object" && !Array.isArray(configured) && "position" in configured ? record2(configured) : void 0;
-  const alignment = typeof layout.slideImageAlignment === "string" ? layout.slideImageAlignment.toLowerCase() : void 0;
-  const position = treatment ? treatment.position : SLIDE_IMAGE_POSITIONS.find((value2) => value2 === alignment) ?? "background";
-  if (!SLIDE_IMAGE_POSITIONS.includes(position)) return void 0;
-  const designSource = treatment ? treatment.src : configured;
-  const root = slide.image, sameSource = root !== void 0 && designSource !== void 0 && assetSource(root) === assetSource(designSource);
-  if (!local && layout.slideImage !== true && !sameSource) return void 0;
-  const replacesContent = root !== void 0 && (designSource === void 0 || sameSource);
-  const value = replacesContent ? root : designSource;
-  const source = assetSource(value);
-  if (typeof source !== "string" || !source) return void 0;
-  const t = treatment ?? {};
-  const fill = t.fill === "crop" || t.fill === "fit" ? t.fill : (own.imageFill ?? deck.imageFill) === "fit" ? "fit" : "crop";
-  const share = finite(t.size, 0.1, 0.9) ?? SLIDE_IMAGE_BAND;
-  const band = { width: round(width * share), height: round(height * share) };
-  const region = position === "left" ? { x: 0, y: 0, width: band.width, height } : position === "right" ? { x: round(width - band.width), y: 0, width: band.width, height } : position === "top" ? { x: 0, y: 0, width, height: band.height } : position === "bottom" ? { x: 0, y: round(height - band.height), width, height: band.height } : { x: 0, y: 0, width, height };
-  const designPath = local ? `${path}.design.slideImage` : "design.slideImage";
-  const kind2 = Object.hasOwn(SLIDE_IMAGE_SHAPES, t.shape) ? t.shape : "rectangle";
-  let box = t.inset === true ? { x: region.x + padding, y: region.y + padding, width: Math.max(scale, region.width - 2 * padding), height: Math.max(scale, region.height - 2 * padding) } : { ...region };
-  const aspect = kind2 === "circle" ? 1 : finite(t.aspectRatio, Number.MIN_VALUE, 10);
-  if (aspect) {
-    const frameWidth = Math.min(box.width, box.height * aspect), frameHeight = frameWidth / aspect;
-    box = { x: box.x + (box.width - frameWidth) / 2, y: box.y + (box.height - frameHeight) / 2, width: frameWidth, height: frameHeight };
-  }
-  box = { x: round(box.x), y: round(box.y), width: round(box.width), height: round(box.height) };
-  const result = {
-    path: designPath,
-    sourcePath: replacesContent ? `${path}.image` : designPath,
-    value,
-    position,
-    fill,
-    region,
-    box,
-    replacesContent,
-    shape: slideImageShape(kind2, box, finite(t.cornerRadius, 0, 0.5))
-  };
-  if (typeof t.alt === "string") result.alt = t.alt;
-  const border = record2(t.border), borderWidth = finite(border.width, 0, 64);
-  if (border.color !== void 0 && borderWidth) result.border = { color: border.color, width: round(borderWidth * scale) };
-  const opacity = finite(t.opacity, 0, 1);
-  if (opacity !== void 0 && opacity < 1) result.opacity = opacity;
-  if (t.recolor === "grayscale") result.recolor = { type: "grayscale" };
-  else if (record2(t.recolor).dark !== void 0 && record2(t.recolor).light !== void 0) result.recolor = { type: "duotone", dark: t.recolor.dark, light: t.recolor.light };
-  const overlay = record2(t.overlay), overlayOpacity = finite(overlay.opacity, 0, 1);
-  if (overlay.color !== void 0 && overlayOpacity !== void 0) {
-    const edge = ["top", "bottom", "left", "right"].includes(overlay.edge) ? overlay.edge : void 0;
-    if (edge && kind2 !== "rectangle") diagnostics.push({ code: "unsupported-image-treatment", path: `${designPath}.overlay.edge`, message: "An edge overlay needs a rectangle frame; a band cannot follow a rounded, circular or hexagonal mask as one native shape. Remove edge or use shape rectangle." });
-    else {
-      const part = finite(overlay.size, 0.05, 1) ?? 0.3;
-      const bandBox = !edge ? box : edge === "top" ? { ...box, height: round(box.height * part) } : edge === "bottom" ? { ...box, y: round(box.y + box.height * (1 - part)), height: round(box.height * part) } : edge === "left" ? { ...box, width: round(box.width * part) } : { ...box, x: round(box.x + box.width * (1 - part)), width: round(box.width * part) };
-      result.overlay = { color: overlay.color, opacity: overlayOpacity, box: bandBox, shape: edge ? slideImageShape("rectangle", bandBox) : result.shape };
-    }
-  }
-  return result;
-}
-var webUrl = /^https?:\/\/\S+$/i;
-function resolveSocialProfile(platform, value, records = [], owner = "organization") {
-  const raw = String(value).trim().replace(/\s+/gu, " ");
-  const display = (url2) => url2.replace(/^https:\/\//i, "");
-  if (webUrl.test(raw)) return { text: display(raw), href: raw, resolved: false };
-  const platformRecord = records.find((item) => item?.id === platform);
-  const base = typeof platformRecord?.baseUrl === "string" && webUrl.test(platformRecord.baseUrl) ? `${platformRecord.baseUrl.replace(/\/+$/u, "")}/{handle}` : void 0;
-  const pattern = (owner === "organization" ? platformRecord?.companyUrlPattern : void 0) ?? platformRecord?.profileUrlPattern ?? base;
-  const prefix = platformRecord?.handlePrefix ?? "";
-  const handle = prefix && raw.startsWith(prefix) ? raw.slice(prefix.length) : raw;
-  if (!handle || typeof pattern !== "string" || !pattern.includes("{handle}")) return { text: raw, resolved: false };
-  const url = pattern.split("{handle}").join(handle);
-  if (!webUrl.test(url)) return { text: raw, resolved: false };
-  return { text: display(url), href: encodeURI(url), resolved: true };
-}
-function layoutFurniture(input, options = {}) {
-  const slide = record2(input), width = options.width ?? 1280, height = options.height ?? 720, scale = Math.min(width, height) / 720;
-  const settings = { ...record2(record2(options.layout).composition), ...record2(slide.composition) };
-  assertComposition(settings);
-  const minimum = (settings.minFontSize ?? 16) * scale, size = Math.max(13 * scale, minimum), padding = (options.textRasterPadding ?? 2) * scale;
-  if (![width, height, scale, minimum, padding].every(Number.isFinite) || width <= 0 || height <= 0 || minimum <= 0 || padding < 0) throw new RangeError("Furniture requires finite positive dimensions and nonnegative raster padding.");
-  const number = options.slideNumber ?? (options.slideIndex ?? 0) + 1;
-  if (!Number.isSafeInteger(number) || number < 1) throw new RangeError("Displayed slide number must be a positive safe integer.");
-  const presentationSlides = options.presentation?.slides, slideCount = options.slideCount ?? (Array.isArray(presentationSlides) && presentationSlides.length ? presentationSlides.length : void 0);
-  if (slideCount !== void 0 && (!Number.isSafeInteger(slideCount) || slideCount < 1)) throw new RangeError("Displayed slide count must be a positive safe integer.");
-  if (options.date !== void 0 && (typeof options.date !== "string" || !parseIsoDate(options.date))) throw new RangeError("The furniture date option must be an ISO YYYY-MM-DD calendar date.");
-  const outlines = options.textMeasurement?.outlineBounds !== void 0, parts = [], diagnostics = [];
-  const sourceRoot = `slides.${options.slideIndex ?? 0}`, organizations = Array.isArray(options.presentation?.organization) ? options.presentation.organization : [options.presentation?.organization];
-  const primaryIndex = organizations.findIndex((item) => record2(item).role === "primary"), organizationIndex = primaryIndex >= 0 ? primaryIndex : organizations.findIndex(Boolean);
-  const organization = record2(organizations[organizationIndex]), organizationRoot = Array.isArray(options.presentation?.organization) ? `organization.${organizationIndex}` : "organization", organizationPath = `${organizationRoot}.name`;
-  const inlinePlatforms = record2(record2(options.presentation?.catalogs).socialPlatforms).records, platformRecords = [...Array.isArray(inlinePlatforms) ? inlinePlatforms : [], ...options.socialPlatforms ?? []];
-  const fontFamily = options.fonts?.body ?? "sans-serif";
-  let headerBottom = 0, footerTop = height, configured = false;
-  const error = (path, message, code = "text-overflow") => diagnostics.push({ code, path, message });
-  for (const kind2 of ["header", "footer"]) {
-    const local = record2(slide.design)[kind2] !== void 0, value = local ? record2(slide.design)[kind2] : options.presentation?.design?.[kind2];
-    if (value === void 0 || value === false) continue;
-    const root = local ? `${sourceRoot}.design.${kind2}` : `design.${kind2}`;
-    if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Header/footer content must be an object or false.");
-    configured = true;
-    const zones = [];
-    for (const [index, zone] of ["left", "center", "right"].entries()) {
-      const content = record2(record2(value)[zone]), path = `${root}.${zone}`, x = width * (0.07 + index * 0.3), zoneWidth = width * 0.26, zoneParts = [];
-      let y = 0;
-      const add = (field, text, generated = false, sourcePath, extras = {}) => {
-        if (text === void 0) return;
-        if (typeof text !== "string") throw new TypeError(`Furniture field ${path}.${field} requires string content.`);
-        const partPath = `${path}.${field}`, style = resolveTextStyle({ fontFamily, fontWeight: 400, italic: false, path: partPath }, options.textMeasurement);
-        const fit = fitText(text, { width: Math.max(Number.MIN_VALUE, zoneWidth - (outlines ? 2 * padding : 0)), height: Number.MAX_VALUE }, size, size, textWidthMeasurer(style, options.textMeasurement));
-        const ink = fit.sourceLines.map((line, index2) => {
-          let outline = null;
-          if (outlines) {
-            for (const segment of line.segments) if (segment.kind === "text") {
-              const bounds = measureTextOutline(text.slice(segment.start, segment.end), size, style, options.textMeasurement);
-              if (bounds) {
-                const next = { ...bounds, x: bounds.x + segment.x };
-                if (!outline) outline = next;
-                else {
-                  const right = Math.max(outline.x + outline.width, next.x + next.width), bottom = Math.max(outline.y + outline.height, next.y + next.height);
-                  outline.x = Math.min(outline.x, next.x);
-                  outline.y = Math.min(outline.y, next.y);
-                  outline.width = right - outline.x;
-                  outline.height = bottom - outline.y;
-                }
-              }
-            }
-          }
-          return { width: line.width, y: index2 * fit.lineHeight, baseline: size + index2 * fit.lineHeight, height: fit.lineHeight, outline };
-        });
-        const natural = outlines ? placeTextLines(ink, { x, y, width: zoneWidth, height: Number.MAX_VALUE }, zone, padding) : void 0;
-        const partHeight = natural?.height ?? fit.sourceLines.length * fit.lineHeight;
-        if (!Number.isFinite(partHeight)) throw new RangeError("Furniture exceeds finite layout coordinates.");
-        const box = { x, y, width: zoneWidth, height: Math.max(scale, partHeight) }, placement = outlines ? placeTextLines(ink, box, zone, padding) : void 0;
-        const accepted = { ...fit, ...placement ? { placement } : {}, overflow: fit.overflow || !!placement?.overflow };
-        zoneParts.push({ type: "text", kind: kind2, zone, field, path: partPath, sourcePath: sourcePath ?? (!generated ? partPath : void 0), generated, text, style, requestedFontSize: 13 * scale, minFontSize: minimum, box, alignment: zone, fit: accepted, ...extras.fields?.length ? { fields: extras.fields } : {}, ...extras.links?.length ? { links: extras.links } : {} });
-        if (accepted.overflow) error(partPath, "Repeated text exceeds its zone at the selected readability floor; change the furniture or slide design.");
-        y += box.height;
-      };
-      if (content.image !== void 0) {
-        const box = { x, y, width: zoneWidth, height: Math.max(32 * scale, Math.min(height * 0.05, 72 * scale)) };
-        zoneParts.push({ type: "image", kind: kind2, zone, field: "image", path: `${path}.image`, sourcePath: `${path}.image`, generated: false, image: content.image, box, alignment: zone });
-        y += box.height;
-      }
-      add("text", content.text);
-      if (content.organization === true) {
-        if (typeof organization.name === "string") add("organization", organization.name, true, organizationPath);
-        else error(`${path}.organization`, "Generated organization name needs a named organization in the presentation.", "unresolved-content");
-      }
-      if (content.socials === true) {
-        const links = Object.entries(record2(organization.socials)).filter(([, value2]) => typeof value2 === "string" && value2.trim()).map(([platform, value2]) => ({ platform, sourcePath: `${organizationRoot}.socials.${platform}`, ...resolveSocialProfile(platform, value2, platformRecords, "organization") }));
-        if (links.length) add("socials", links.map((link) => link.text).join("\n"), true, `${organizationRoot}.socials`, { links });
-        else error(`${path}.socials`, "Generated social profiles need a primary organization with socials.", "unresolved-content");
-      }
-      if (content.section === true) {
-        if (typeof slide.section === "string") add("section", slide.section, true, `${sourceRoot}.section`);
-        else error(`${path}.section`, "Generated section needs a literal slide section.", "unresolved-content");
-      }
-      for (const setting of ["slideNumberFormat", "dateFormat"]) if (content[setting] !== void 0 && typeof content[setting] !== "string") throw new TypeError(`Furniture setting ${path}.${setting} requires a string.`);
-      if (content.slideNumber === true) {
-        const resolved = formatSlideNumber(content.slideNumberFormat ?? DEFAULT_SLIDE_NUMBER_FORMAT, number, slideCount);
-        if ("error" in resolved) error(`${path}.slideNumberFormat`, resolved.error, "unresolved-content");
-        else add("slideNumber", resolved.text, true, void 0, { fields: resolved.fields });
-      }
-      if (content.date === true) {
-        const format = content.dateFormat ?? DEFAULT_FURNITURE_DATE_FORMAT;
-        if (options.date === void 0) error(`${path}.date`, "A current date needs a host-supplied ISO date option. For fixed content use a literal date, or an ISO date with dateFormat.", "unresolved-content");
-        else {
-          const resolved = formatFurnitureDate(options.date, format);
-          if ("error" in resolved) error(`${path}.dateFormat`, resolved.error, "unresolved-content");
-          else add("date", resolved.text, true, void 0, { fields: [{ type: "date", start: 0, end: resolved.text.length, format }] });
-        }
-      } else if (typeof content.date === "string") {
-        if (content.dateFormat === void 0) add("date", content.date);
-        else {
-          const resolved = formatFurnitureDate(content.date, content.dateFormat);
-          if ("error" in resolved) error(`${path}.${parseIsoDate(content.date) ? "dateFormat" : "date"}`, resolved.error, "unresolved-content");
-          else add("date", resolved.text, true, `${path}.date`);
-        }
-      }
-      zones.push(zoneParts);
-    }
-    const tallest = Math.max(0, ...zones.map((zone) => zone.reduce((sum, part) => sum + part.box.height, 0)));
-    if (!tallest) continue;
-    const top = kind2 === "header" ? height * 0.025 : Math.max(height * 0.025, height - height * 0.04 - tallest);
-    if (kind2 === "header") headerBottom = top + tallest;
-    else footerTop = top;
-    for (const zone of zones) for (const part of zone) {
-      part.box.y += top;
-      if (part.type === "text" && part.fit.placement) for (const line of part.fit.placement.lines) {
-        line.y += top;
-        line.baseline += top;
-        if (line.outline) line.outline.y += top;
-      }
-      if (part.box.y + part.box.height > height - height * 0.04 + 0.01) error(part.path, "Repeated header/footer content extends beyond the usable slide height. Change its content or design before pagination.");
-      parts.push(part);
-    }
-  }
-  if (headerBottom > footerTop + 0.01) error(parts.find((part) => part.kind === "footer")?.path ?? sourceRoot, "Header and footer content overlap; repeated content cannot be repaired by splitting body content.");
-  return { algorithm: "furniture-flow-v2", configured, textMeasurement: options.textMeasurement ? "provided" : "estimated", textOutlines: outlines ? "provided" : "unavailable", parts, headerBottom, footerTop, diagnostics, overflow: diagnostics.length > 0 };
-}
-var textSegments = new Intl.Segmenter("und", { granularity: "grapheme" });
-function measureText(text, fontSize) {
-  let units = 0;
-  for (const character of text) {
-    if (/\p{Mark}|\u200d|\ufe0f/u.test(character)) continue;
-    units += character === " " ? 0.32 : /[A-Z0-9]/.test(character) ? 0.62 : character.codePointAt(0) > 11904 ? 1 : 0.54;
-  }
-  return units * fontSize;
-}
-function wrapText(text, width, fontSize, measure = measureText) {
-  return fitSourceText(text, { width, height: Number.MAX_VALUE }, fontSize, fontSize, 1, measure, true).lines;
-}
-function fitText(text, box, requestedSize = 25, minFontSize = 16, measure = measureText) {
-  if (![box.width, box.height, requestedSize, minFontSize].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || requestedSize <= 0 || minFontSize <= 0) {
-    throw new RangeError("Text dimensions and font sizes must be finite and positive.");
-  }
-  return fitSourceText(text, box, Math.max(requestedSize, minFontSize), minFontSize, 1, measure, true);
-}
-function fitAtSizes(layout, requested, minimum, step = 1) {
-  const start = Math.max(requested, minimum);
-  if (![start, minimum, step].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("Readable font sizes and fitting steps must be finite and positive.");
-  for (let trial = 0; trial <= 64; trial++) {
-    const size = trial === 64 ? minimum : Math.max(minimum, start - trial * step), result = layout(size);
-    if (!result.overflow || size === minimum) return result;
-  }
-  throw new Error("Text fitting did not evaluate its bounded floor trial.");
-}
-function layoutQuote(value, box, options = {}) {
-  const shorthand = typeof value === "string";
-  const quote = shorthand ? { text: value } : value;
-  if (!quote || Array.isArray(quote) || typeof quote.text !== "string" || [quote.attribution, quote.source].some((field) => field !== void 0 && typeof field !== "string")) {
-    throw new TypeError("Quote content must be a string or a text object with optional string attribution/source.");
-  }
-  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale;
-  if (![box.x, box.y, box.width, box.height, scale, minimum].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || scale <= 0 || minimum <= 0) {
-    throw new RangeError("Quote dimensions, scale and minimum font size must be finite and positive.");
-  }
-  if (options.overflow !== void 0 && !["warn", "error"].includes(options.overflow)) throw new RangeError("Invalid quote overflow policy.");
-  const path = options.path ?? "quote";
-  const diagnostics = [], parts = [];
-  const report = (reason, diagnosticPath, roles, message) => diagnostics.push({ code: "text-overflow", reason, path: diagnosticPath, parts: roles, message });
-  const source = (sourcePath, text, outputStart) => ({ path: sourcePath, start: 0, end: text.length, outputStart, outputEnd: outputStart + text.length });
-  const add = (role, text, sources, area, fontSize, fontFamily, fontWeight, partPath) => {
-    const requestedStyle = { fontFamily, fontWeight, italic: false, path: partPath };
-    const style = resolveTextStyle({ ...requestedStyle }, options.textMeasurement);
-    const requestedFontSize = Math.max(fontSize * scale, minimum);
-    const part = { role, path: partPath, text, sources, box: area, requestedFontSize, minFontSize: minimum, requestedStyle, style };
-    parts.push(part);
-    return part;
-  };
-  let footer = "";
-  const footerSources = [];
-  for (const field of ["attribution", "source"]) {
-    const text = quote[field];
-    if (!text) continue;
-    if (footer) footer += " - ";
-    footerSources.push(source(`${path}.${field}`, text, footer.length));
-    footer += text;
-  }
-  const bodyPath = shorthand ? path : `${path}.text`;
-  const body = add(
-    "body",
-    `"${quote.text}"`,
-    [source(bodyPath, quote.text, 1)],
-    { x: box.x + 18, y: box.y + 18, width: box.width - 36, height: box.height - (footer ? 94 : 36) },
-    28,
-    options.fonts?.heading ?? "sans-serif",
-    600,
-    bodyPath
-  );
-  const attribution = footer ? add(
-    "footer",
-    footer,
-    footerSources,
-    { x: box.x + 18, y: box.y + box.height - 58, width: box.width - 36, height: 40 },
-    17,
-    options.fonts?.body ?? "sans-serif",
-    500,
-    path
-  ) : void 0;
-  const usable = (area) => [area.x, area.y, area.width, area.height].every(Number.isFinite) && area.width > 0 && area.height > 0;
-  const fit = (part, area, size = part.requestedFontSize, floor = minimum) => usable(area) ? fitText(part.text, area, size, floor, textWidthMeasurer(part.style, options.textMeasurement)) : void 0;
-  const inner = { x: box.x + 18, y: box.y + 18, width: box.width - 36, height: box.height - 36 };
-  if (!attribution) body.fit = fit(body, body.box);
-  else if (usable(inner) && inner.height > 18) {
-    const available = inner.height - 18;
-    const preferredBody = fit(body, inner, body.requestedFontSize, body.requestedFontSize);
-    const minimumBody = body.requestedFontSize === minimum ? preferredBody : fit(body, inner, minimum, minimum);
-    const preferredBodyHeight = preferredBody.lines.length * preferredBody.lineHeight;
-    const minimumBodyHeight = minimumBody.lines.length * minimumBody.lineHeight;
-    let selected;
-    for (const size of /* @__PURE__ */ new Set([attribution.requestedFontSize, minimum])) {
-      const natural = fit(attribution, inner, size, size);
-      const naturalHeight = natural.lines.length * natural.lineHeight;
-      const preferredHeight = Math.max(40, naturalHeight);
-      const bodyReservation = Math.min(minimumBodyHeight, Math.max(minimumBody.lineHeight, available - natural.lineHeight));
-      const footerHeight = preferredBodyHeight + preferredHeight <= available + 0.01 ? preferredHeight : Math.min(naturalHeight, Math.max(0, available - bodyReservation));
-      const bodyBox = { ...inner, height: available - footerHeight };
-      const footerBox = { ...inner, y: inner.y + inner.height - footerHeight, height: footerHeight };
-      const bodyFit = fit(body, bodyBox);
-      const footerFit = usable(footerBox) ? { ...natural, overflow: natural.overflow || naturalHeight > footerHeight + 0.01 } : void 0;
-      const overflow = !bodyFit || !footerFit || bodyFit.overflow || footerFit.overflow;
-      const score = (body.requestedFontSize - (bodyFit?.fontSize ?? minimum) + attribution.requestedFontSize - size) / scale;
-      if (!selected || !overflow && (selected.overflow || score < selected.score) || overflow && selected.overflow) {
-        selected = { bodyBox, footerBox, bodyFit, footerFit, score, overflow };
-      }
-    }
-    if (selected) {
-      body.box = selected.bodyBox;
-      body.fit = selected.bodyFit;
-      attribution.box = selected.footerBox;
-      attribution.fit = selected.footerFit;
-    }
-  }
-  for (const part of parts) {
-    const area = part.box;
-    if (!part.fit) {
-      report("invalid-part-box", part.path, [part.role], `Quote ${part.role} has no usable space after its insets; increase the cell size or change the arrangement.`);
-    } else if (part.fit.overflow) {
-      report("text-fit", part.path, [part.role], `Quote ${part.role} exceeds its available space at the readability floor; increase its space or change the arrangement.`);
-    }
-    if (usable(area) && (area.x < box.x || area.y < box.y || area.x + area.width > box.x + box.width + 0.01 || area.y + area.height > box.y + box.height + 0.01)) {
-      report("part-outside-cell", part.path, [part.role], `Quote ${part.role} extends outside its cell; increase the cell size or change the arrangement.`);
-    }
-  }
-  if (body?.fit && attribution?.fit && body.box.y + body.fit.lines.length * body.fit.lineHeight > attribution.box.y + 0.01 && attribution.box.y + attribution.fit.lines.length * attribution.fit.lineHeight > body.box.y + 0.01) {
-    report("part-overlap", path, ["body", "footer"], "Quote body and footer line boxes overlap; do not accept this layout without more space.");
-  }
-  if (diagnostics.length && options.overflow === "error") throw new OPFCompositionError(diagnostics);
-  return { algorithm: "quote-flow-v1", textMeasurement: options.textMeasurement ? "provided" : "estimated", parts, diagnostics, overflow: diagnostics.length > 0 };
-}
-function layoutMetric(value, box, options = {}) {
-  const scalar = typeof value === "string" || typeof value === "number";
-  const metric = scalar ? { value } : value;
-  const isValue = (input) => typeof input === "string" || typeof input === "number" && Number.isFinite(input);
-  if (!metric || Array.isArray(metric) || !isValue(metric.value) || [metric.label, metric.description, metric.unit].some((field) => field !== void 0 && typeof field !== "string") || metric.delta !== void 0 && !isValue(metric.delta) || metric.trend !== void 0 && !["up", "down", "flat"].includes(metric.trend)) {
-    throw new TypeError("Metric content requires a finite numeric or string value and schema-valid display metadata.");
-  }
-  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale;
-  const rasterPadding = (options.textRasterPadding ?? 1) * scale, hasOutlines = options.textMeasurement?.outlineBounds !== void 0;
-  if (![box.x, box.y, box.width, box.height, box.x + box.width, box.y + box.height, scale, minimum, Math.max(76 * scale, minimum) * 1.22].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || scale <= 0 || minimum <= 0) {
-    throw new RangeError("Metric dimensions, scale and minimum font size must be finite and positive.");
-  }
-  if (!Number.isFinite(rasterPadding) || rasterPadding < 0) throw new RangeError("Metric raster padding must be finite and nonnegative.");
-  if (options.overflow !== void 0 && !["warn", "error"].includes(options.overflow)) throw new RangeError("Invalid metric overflow policy.");
-  const alignment = options.align ?? "left";
-  if (!["left", "center", "right"].includes(alignment)) throw new RangeError("Invalid metric alignment.");
-  const sourcePath = options.path ?? "metric", parts = [], diagnostics = [];
-  for (const role of ["value", "unit", "label", "description", "delta", "trend"]) {
-    const sourceValue = metric[role];
-    if (sourceValue === void 0) continue;
-    const text = String(sourceValue), path = scalar ? sourcePath : `${sourcePath}.${role}`;
-    const nominal = role === "value" ? Math.min(76 * scale, box.height * 0.28) : (role === "description" ? 20 : role === "trend" ? 18 : 23) * scale;
-    const requestedStyle = { fontFamily: (role === "value" ? options.fonts?.heading : options.fonts?.body) ?? "sans-serif", fontWeight: role === "value" ? 800 : role === "description" ? 400 : 500, italic: false, path };
-    const part = {
-      role,
-      path,
-      text,
-      sources: [{ path, value: sourceValue, start: 0, end: text.length }],
-      visible: role === "value" || text.length > 0,
-      linePositions: [],
-      box: { ...box, height: 0 },
-      requestedFontSize: Math.max(nominal, minimum),
-      minFontSize: minimum,
-      requestedStyle,
-      style: resolveTextStyle({ ...requestedStyle }, options.textMeasurement)
-    };
-    if (!part.visible) part.fit = { lines: [], sourceLines: [], fontSize: part.requestedFontSize, lineHeight: part.requestedFontSize * 1.22, tabSize: 4, tabWidth: 0, overflow: false };
-    parts.push(part);
-  }
-  const primary = parts[0], metadata = parts.filter((part) => part !== primary && part.visible), unit = metadata.find((part) => part.role === "unit");
-  const usable = (area) => [area.x, area.y, area.width, area.height, area.x + area.width, area.y + area.height].every(Number.isFinite) && area.width > 0 && area.height > 0;
-  const occupied = (fit) => fit.placement?.height ?? fit.lines.length * fit.lineHeight;
-  const gap = 8 * scale, primaryGap = 12 * scale;
-  const lineInk = (part, fit) => fit.sourceLines.map((line, index) => {
-    let outline = null;
-    for (const segment of line.segments) {
-      if (segment.kind !== "text") continue;
-      const bounds = measureTextOutline(part.text.slice(segment.start, segment.end), fit.fontSize, part.style, options.textMeasurement);
-      if (!bounds) continue;
-      const next = { ...bounds, x: segment.x + bounds.x };
-      if (!outline) outline = next;
-      else {
-        const right = Math.max(outline.x + outline.width, next.x + next.width), bottom = Math.max(outline.y + outline.height, next.y + next.height);
-        outline.x = Math.min(outline.x, next.x);
-        outline.y = Math.min(outline.y, next.y);
-        outline.width = right - outline.x;
-        outline.height = bottom - outline.y;
-      }
-    }
-    return { width: line.width, y: index * fit.lineHeight, baseline: fit.fontSize + index * fit.lineHeight, height: fit.lineHeight, outline };
-  });
-  const place = (part, fit, width) => {
-    if (!hasOutlines) return fit;
-    const placement = placeTextLines(lineInk(part, fit), { x: 0, y: 0, width, height: Number.MAX_VALUE }, alignment, rasterPadding);
-    return { ...fit, placement, overflow: placement.overflow };
-  };
-  const naturalWidth = (part, fit) => {
-    if (!hasOutlines) return Math.max(...fit.sourceLines.map((line) => line.width));
-    const width = Math.max(...lineInk(part, fit).map((line) => Math.max(line.width, line.outline ? line.outline.x + line.outline.width : 0) - Math.min(0, line.outline?.x ?? 0)));
-    return width > 0 ? width + 2 * rasterPadding : 0;
-  };
-  const cache = /* @__PURE__ */ new Map();
-  const measure = (part, size, width) => {
-    const key = JSON.stringify([part.role, size, width]);
-    let fit = cache.get(key);
-    if (!fit) {
-      fit = fitCodeText(part.text, { ...box, width: hasOutlines ? Math.max(Number.MIN_VALUE, width - 2 * rasterPadding) : width }, size, size, scale, textWidthMeasurer(part.style, options.textMeasurement));
-      fit = place(part, fit, width);
-      if (!Number.isFinite(occupied(fit))) throw new RangeError("Metric text layout exceeds finite coordinates.");
-      cache.set(key, fit);
-    }
-    return fit;
-  };
-  const fitValue = (area, singleLine) => {
-    if (!usable(area)) return void 0;
-    for (let step = 0; step <= 76; step++) {
-      const size = Math.max(minimum, primary.requestedFontSize - step * scale);
-      const natural = measure(primary, size, area.width);
-      const fit = { ...natural, overflow: !!natural.placement?.overflow || singleLine && natural.lines.length !== 1 || occupied(natural) > area.height + 0.01 || natural.sourceLines.some((line) => line.width > area.width + 0.01) };
-      if (!fit.overflow || size === minimum) return fit;
-    }
-  };
-  let selected, attempts = 0;
-  const reductions = Math.min(23, Math.ceil(Math.max(0, ...metadata.map((part) => (part.requestedFontSize - minimum) / scale))));
-  for (let reduction = 0; reduction <= reductions; reduction++) {
-    const measured = new Map(metadata.map((part) => [part, measure(part, Math.max(minimum, part.requestedFontSize - reduction * scale), box.width)]));
-    const measuredUnit = unit ? measured.get(unit) : void 0;
-    const unitWidth = unit && measuredUnit ? naturalWidth(unit, measuredUnit) : 0;
-    const unitFit = unit && measuredUnit && unitWidth > 0 ? place(unit, measuredUnit, unitWidth) : measuredUnit;
-    const inline = unitFit?.lines.length === 1 && unitWidth > 0 && unitWidth <= box.width * 0.35 && unitWidth + gap < box.width;
-    for (const arrangement of inline ? ["inline-unit", "stacked"] : ["stacked"]) {
-      attempts++;
-      const tail = metadata.filter((part) => arrangement !== "inline-unit" || part !== unit);
-      const tailHeight = tail.reduce((sum, part) => sum + occupied(measured.get(part)), 0) + Math.max(0, tail.length - 1) * gap;
-      if (!Number.isFinite(tailHeight)) throw new RangeError("Metric metadata exceeds finite coordinates.");
-      const area = { ...box, width: arrangement === "inline-unit" ? box.width - unitWidth - gap : box.width, height: box.height - tailHeight - (tail.length ? primaryGap : 0) };
-      const valueFit = fitValue(area, arrangement === "inline-unit"), valueHeight = valueFit ? occupied(valueFit) : 0;
-      const allocations = [];
-      let primaryHeight = valueHeight;
-      if (arrangement === "inline-unit" && unit && unitFit && valueFit) {
-        const valueBaseline = valueFit.placement?.lines.at(-1)?.baseline ?? valueHeight - valueFit.lineHeight + valueFit.fontSize;
-        const unitBaseline = unitFit.placement?.lines.at(-1)?.baseline ?? occupied(unitFit) - unitFit.lineHeight + unitFit.fontSize;
-        const valueY = box.y + Math.max(0, unitBaseline - valueBaseline), unitY = box.y + Math.max(0, valueBaseline - unitBaseline);
-        const measuredWidth = naturalWidth(primary, valueFit);
-        const valueWidth = Math.min(area.width, measuredWidth || valueFit.fontSize);
-        allocations.push({ part: primary, box: { ...area, y: valueY, width: valueWidth, height: valueHeight }, fit: place(primary, valueFit, valueWidth) });
-        allocations.push({ part: unit, box: { x: box.x + valueWidth + gap, y: unitY, width: unitWidth, height: occupied(unitFit) }, fit: { ...unitFit, overflow: !!unitFit.placement?.overflow } });
-        primaryHeight = Math.max(valueY - box.y + valueHeight, unitY - box.y + occupied(unitFit));
-      } else allocations.push({ part: primary, box: valueFit ? { ...area, height: valueHeight } : area, fit: valueFit });
-      let y = box.y + primaryHeight + (tail.length ? primaryGap : 0);
-      for (const part of tail) {
-        const natural = measured.get(part), height = occupied(natural);
-        allocations.push({ part, box: { ...box, y, height }, fit: { ...natural, overflow: !!natural.placement?.overflow || natural.sourceLines.some((line) => line.width > box.width + 0.01) } });
-        y += height + gap;
-      }
-      const overflow = !valueFit || valueFit.overflow || arrangement === "inline-unit" && valueFit.lines.length !== 1 || primaryHeight > area.height + 0.01 || allocations.some(({ box: area2, fit }) => !fit || fit.overflow || !usable(area2) || area2.y + area2.height > box.y + box.height + 0.01);
-      const score = allocations.reduce((sum, { part, fit }) => sum + (part.requestedFontSize - (fit?.fontSize ?? minimum)) / scale, 0);
-      const candidate = { arrangement, allocations, score, overflow };
-      if (!selected || !overflow && (selected.overflow || score < selected.score) || overflow && selected.overflow) selected = candidate;
-    }
-    if (selected && !selected.overflow && selected.score === 0) break;
-  }
-  for (const allocation of selected.allocations) {
-    allocation.part.box = allocation.box;
-    allocation.part.fit = allocation.fit;
-  }
-  const alignmentFactor = alignment === "center" ? 0.5 : alignment === "right" ? 1 : 0;
-  if (selected.arrangement === "inline-unit" && unit) {
-    const offset = (box.width - (unit.box.x + unit.box.width - box.x)) * alignmentFactor;
-    primary.box.x += offset;
-    unit.box.x += offset;
-  }
-  for (const part of parts) if (part.fit) {
-    if (part.fit.placement) {
-      part.fit = { ...part.fit, placement: { ...part.fit.placement, lines: part.fit.placement.lines.map((line) => ({ ...line, x: line.x + part.box.x, y: line.y + part.box.y, baseline: line.baseline + part.box.y, outline: line.outline ? { ...line.outline, x: line.outline.x + part.box.x, y: line.outline.y + part.box.y } : null })) } };
-      part.linePositions = part.fit.placement.lines.map(({ x, baseline }) => ({ x, baseline }));
-    } else part.linePositions = part.fit.sourceLines.map((line, index) => ({
-      x: part.box.x + (part.box.width - line.width) * alignmentFactor,
-      baseline: part.box.y + part.fit.fontSize + index * part.fit.lineHeight
-    }));
-  }
-  const report = (reason, part, roles, message) => diagnostics.push({ code: "text-overflow", reason, path: part.path, parts: roles, message });
-  for (const part of parts.filter((part2) => part2.visible)) {
-    if (!part.fit || !usable(part.box)) report("invalid-part-box", part, [part.role], `Metric ${part.role} has no usable space after metadata; increase the cell or change the arrangement.`);
-    else if (part.fit.overflow) report("text-fit", part, [part.role], `Metric ${part.role} exceeds its space at the readability floor; increase the cell or change the arrangement.`);
-    if (usable(part.box) && (part.box.x < box.x || part.box.y < box.y || part.box.x + part.box.width > box.x + box.width + 0.01 || part.box.y + part.box.height > box.y + box.height + 0.01)) {
-      report("part-outside-cell", part, [part.role], `Metric ${part.role} extends outside its cell; increase the cell or change the arrangement.`);
-    }
-  }
-  const visible = parts.filter((part) => part.visible && part.fit);
-  for (const [index, first] of visible.entries()) for (const second of visible.slice(index + 1)) {
-    if (first.box.x < second.box.x + second.box.width - 0.01 && second.box.x < first.box.x + first.box.width - 0.01 && first.box.y < second.box.y + occupied(second.fit) - 0.01 && second.box.y < first.box.y + occupied(first.fit) - 0.01) {
-      report("part-overlap", first, [first.role, second.role], "Metric part line boxes overlap; do not accept this layout without more space.");
-    }
-  }
-  if (diagnostics.length && options.overflow === "error") throw new OPFCompositionError(diagnostics);
-  return { algorithm: "metric-flow-v1", alignment, textMeasurement: options.textMeasurement ? "provided" : "estimated", arrangement: selected.arrangement, attempts, parts, diagnostics, overflow: diagnostics.length > 0 };
-}
-function layoutTimeline(value, box, options = {}) {
-  const shorthand = Array.isArray(value), timeline = shorthand ? { events: value } : value;
-  if (!timeline || !Array.isArray(timeline.events) || !timeline.events.length || [timeline.name, timeline.description].some((field) => field !== void 0 && typeof field !== "string") || timeline.events.some((event) => !event || typeof event.what !== "string" || [event.when, event.description].some((field) => field !== void 0 && typeof field !== "string"))) {
-    throw new TypeError("Timeline content requires ordered events with string labels and optional string metadata.");
-  }
-  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale, padding = (options.textRasterPadding ?? 1) * scale;
-  if (![box.x, box.y, box.width, box.height, scale, minimum, padding].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || scale <= 0 || minimum <= 0 || padding < 0) throw new RangeError("Timeline dimensions, scale and minimum must be positive, with finite nonnegative raster padding.");
-  if (options.overflow !== void 0 && !["warn", "error"].includes(options.overflow)) throw new RangeError("Invalid timeline overflow policy.");
-  const outlines = options.textMeasurement?.outlineBounds !== void 0;
-  if (outlines && typeof options.textMeasurement?.outlineBounds !== "function") throw new TypeError("Text outline provider must be a function.");
-  const path = options.path ?? "timeline", eventPath = (index) => shorthand ? `${path}.${index}` : `${path}.events.${index}`;
-  const fonts = resolveFontFamilies(options.fonts), source = [];
-  const add = (role, text, partPath, size, weight, eventIndex) => {
-    if (text === void 0) return;
-    const requestedStyle = { fontFamily: fonts.body, fontWeight: weight, italic: false, path: partPath };
-    source.push({ role, eventIndex, path: partPath, text, sources: [{ path: partPath, start: 0, end: text.length }], box: { ...box }, alignment: "center", requestedFontSize: Math.max(size * scale, minimum), minFontSize: minimum, requestedStyle, style: resolveTextStyle({ ...requestedStyle }, options.textMeasurement) });
-  };
-  add("name", timeline.name, `${path}.name`, 24, 700);
-  add("description", timeline.description, `${path}.description`, 18, 400);
-  timeline.events.forEach((event, index) => {
-    add("when", event.when, `${eventPath(index)}.when`, 16, 500, index);
-    add("what", event.what, `${eventPath(index)}.what`, 16, 500, index);
-    add("event-description", event.description, `${eventPath(index)}.description`, 16, 500, index);
-  });
-  const metadata = [], events = timeline.events.map(() => []);
-  for (const part of source) if (part.eventIndex === void 0) metadata.push(part);
-  else events[part.eventIndex].push(part);
-  const cache = /* @__PURE__ */ new Map();
-  const measure = (part, size, width, alignment) => {
-    const key = JSON.stringify([part.path, size, width, alignment]);
-    let measured = cache.get(key);
-    if (measured) return measured;
-    const fit = fitText(part.text, { width: Math.max(Number.MIN_VALUE, width - (outlines ? 2 * padding : 0)), height: Number.MAX_VALUE }, size, size, textWidthMeasurer(part.style, options.textMeasurement));
-    const ink = fit.sourceLines.map((line, index) => {
-      let left = Infinity, top = Infinity, right = -Infinity, bottom = -Infinity, hasInk = false;
-      if (outlines) {
-        for (const segment of line.segments) if (segment.kind === "text") {
-          const outline = measureTextOutline(part.text.slice(segment.start, segment.end), size, part.style, options.textMeasurement);
-          if (outline) {
-            hasInk = true;
-            left = Math.min(left, outline.x + segment.x);
-            top = Math.min(top, outline.y);
-            right = Math.max(right, outline.x + segment.x + outline.width);
-            bottom = Math.max(bottom, outline.y + outline.height);
-          }
-        }
-      }
-      return { width: line.width, y: index * fit.lineHeight, baseline: size + index * fit.lineHeight, height: fit.lineHeight, outline: hasInk ? { x: left, y: top, width: right - left, height: bottom - top } : null };
-    });
-    const placement = outlines ? placeTextLines(ink, { x: 0, y: 0, width, height: Number.MAX_VALUE }, alignment, padding) : void 0;
-    const height = placement?.height ?? fit.sourceLines.length * fit.lineHeight;
-    if (!Number.isFinite(height)) throw new RangeError("Timeline text exceeds finite layout coordinates.");
-    measured = { fit, ink, height };
-    cache.set(key, measured);
-    return measured;
-  };
-  let selected, attempts = 0;
-  let reductionLimit = 0;
-  for (const part of source) reductionLimit = Math.max(reductionLimit, (part.requestedFontSize - minimum) / scale);
-  const reductions = Math.min(24, Math.ceil(reductionLimit));
-  for (let reduction = 0; reduction <= reductions; reduction++) {
-    for (const arrangement of ["alternating", "vertical"]) {
-      attempts++;
-      const parts = [], markers = [], diagnostics = [];
-      let score2 = 0;
-      const report = (part, reason, message, excess = 1) => {
-        diagnostics.push({ code: "text-overflow", reason, path: part.path, message });
-        score2 += Math.max(1, excess);
-      };
-      const place = (part, x, y2, width, alignment) => {
-        const measured = measure(part, Math.max(minimum, part.requestedFontSize - reduction * scale), Math.max(scale, width), alignment);
-        const area = { x, y: y2, width: Math.max(scale, width), height: Math.max(scale, measured.height) }, placement = outlines ? placeTextLines(measured.ink, area, alignment, padding) : void 0;
-        const fit = { ...measured.fit, ...placement ? { placement } : {}, overflow: measured.fit.overflow || !!placement?.overflow };
-        const accepted = { ...part, box: area, alignment, fit };
-        parts.push(accepted);
-        if (fit.overflow) report(accepted, "text-fit", "Timeline field exceeds its readable width; increase its space or split the timeline.");
-        if (area.x < box.x - 0.01 || area.y < box.y - 0.01 || area.x + area.width > box.x + box.width + 0.01 || area.y + area.height > box.y + box.height + 0.01) report(accepted, "part-outside-cell", "Timeline field extends outside its cell; increase the cell or paginate events.", Math.max(area.x + area.width - box.x - box.width, area.y + area.height - box.y - box.height));
-        return accepted;
-      };
-      let y = box.y;
-      for (const part of metadata) {
-        const placed = place(part, box.x, y, box.width, "center");
-        y += placed.box.height + 8 * scale;
-      }
-      const available = box.y + box.height - y, count = events.length, radius = Math.min(9 * scale, box.width / Math.max(2, count) / 5, Math.max(scale, available) * 0.04);
-      if (arrangement === "alternating") {
-        const width = box.width / Math.max(2, count), step = (box.width - width) / Math.max(1, count - 1), start = count === 1 ? box.x + box.width / 2 : box.x + width / 2;
-        const lineY = y + Math.max(scale, available) * 0.46;
-        events.forEach((fields2, index) => {
-          const x = start + index * step, top = index % 2 === 0 ? y : lineY + 24 * scale, bottom = index % 2 === 0 ? lineY - 24 * scale : box.y + box.height;
-          markers.push({ path: eventPath(index), eventIndex: index, x, y: lineY, radius });
-          let cursor = top;
-          for (const part of fields2) {
-            const placed = place(part, x - width / 2, cursor, width, "center");
-            cursor += placed.box.height;
-            if (cursor > bottom + 0.01) report(placed, "event-space", "Timeline event labels exceed their side of the connector; change the arrangement or paginate events.", cursor - bottom);
-          }
-        });
-      } else {
-        const x = box.x + radius, textX = box.x + 24 * scale, width = box.width - 24 * scale;
-        events.forEach((fields2, index) => {
-          const top = y;
-          let first2;
-          for (const part of fields2) {
-            const placed = place(part, textX, y, width, "left");
-            first2 ??= placed;
-            y += placed.box.height;
-          }
-          markers.push({ path: eventPath(index), eventIndex: index, x, y: top + Math.min(first2?.box.height ?? 2 * radius, 2 * radius) / 2, radius });
-          y += 16 * scale;
-        });
-      }
-      for (const marker of markers) if (marker.x - marker.radius < box.x - 0.01 || marker.y - marker.radius < box.y - 0.01 || marker.x + marker.radius > box.x + box.width + 0.01 || marker.y + marker.radius > box.y + box.height + 0.01) {
-        diagnostics.push({ code: "text-overflow", reason: "event-space", path: marker.path, message: "Timeline marker has no usable space; increase the cell or paginate events." });
-        score2 += 1;
-      }
-      const first = markers[0], last = markers.at(-1), connector = { x1: first.x, y1: first.y, x2: last.x, y2: last.y };
-      const candidate = { arrangement, parts, markers, connector, diagnostics, score: score2 };
-      if (!selected || score2 < selected.score) selected = candidate;
-      if (!diagnostics.length) break;
-    }
-    if (!selected.diagnostics.length) break;
-  }
-  const { score, ...result } = selected;
-  if (result.diagnostics.length && options.overflow === "error") throw new OPFCompositionError(result.diagnostics);
-  return { algorithm: "timeline-flow-v1", attempts, textMeasurement: options.textMeasurement ? "provided" : "estimated", textOutlines: outlines ? "provided" : "unavailable", ...result, overflow: result.diagnostics.length > 0 };
-}
-function fitCodeText(text, box, size, minimum, step, measure) {
-  return fitSourceText(text, box, size, minimum, step, measure);
-}
-function fitSourceText(text, box, size, minimum, step, measure, prose = false) {
-  const layout = (fontSize) => {
-    const tabWidth = measure(" ", fontSize) * 4;
-    if (!Number.isFinite(tabWidth) || text.includes("	") && tabWidth <= 0) throw new RangeError("Text tabs require a positive finite measured space advance.");
-    const measureLine = (start2, end2, record3 = false) => {
-      let x = 0, offset = start2;
-      const segments = [];
-      for (const [index, segment] of text.slice(start2, end2).split("	").entries()) {
-        if (index) {
-          const next = (Math.floor(x / tabWidth + 1e-9) + 1) * tabWidth;
-          if (record3) segments.push({ kind: "tab", start: offset, end: offset + 1, x, width: next - x });
-          x = next;
-          offset++;
-        }
-        if (segment) {
-          const advance = measure(segment, fontSize);
-          if (record3) segments.push({ kind: "text", start: offset, end: offset + segment.length, x, width: advance });
-          x += advance;
-          offset += segment.length;
-        }
-      }
-      return { width: x, segments };
-    };
-    const width = (start2, end2) => measureLine(start2, end2).width;
-    const sourceLines = [];
-    let start = 0, end = 0;
-    const push = (last, nextStart, boundary) => {
-      sourceLines.push({ start, end: last, nextStart, boundary, ...measureLine(start, last, true) });
-      start = nextStart;
-      end = nextStart;
-    };
-    const tokens = prose ? /\r\n|\r|\n|[^\S\r\n\u00a0\u202f\ufeff]+|(?:[^\s]|\u00a0|\u202f|\ufeff)+/gu : /\r\n|\r|\n|[^\S\r\n]+|[^\s]+/gu;
-    for (const token of text.matchAll(tokens)) {
-      if (token.index === void 0) throw new Error("Missing code token source offset.");
-      const a = token.index, b = a + token[0].length;
-      if (/^[\r\n]/.test(token[0])) {
-        push(a, b, "hard");
-        continue;
-      }
-      if (width(start, b) <= box.width + 0.01) {
-        end = b;
-        continue;
-      }
-      if (end > start && /\S/u.test(text.slice(start, end))) push(a, a, "soft");
-      if (width(start, b) <= box.width + 0.01) {
-        end = b;
-        continue;
-      }
-      if (prose && /[\u00a0\u202f\u2060\ufeff]/u.test(token[0])) {
-        end = b;
-        continue;
-      }
-      for (const segment of textSegments.segment(token[0])) {
-        const next = a + segment.index + segment.segment.length;
-        if (end > start && width(start, next) > box.width + 0.01) push(a + segment.index, a + segment.index, "soft");
-        end = next;
-      }
-    }
-    push(end, end, "end");
-    const lineHeight = fontSize * 1.22;
-    return {
-      lines: sourceLines.map((line) => text.slice(line.start, line.end)),
-      sourceLines,
-      fontSize,
-      lineHeight,
-      tabSize: 4,
-      tabWidth,
-      overflow: sourceLines.length * lineHeight > box.height + 0.01 || sourceLines.some((line) => line.width > box.width + 0.01)
-    };
-  };
-  return fitAtSizes(layout, size, minimum, step);
-}
-function layoutCode(value, box, options = {}) {
-  const shorthand = typeof value === "string", code = shorthand ? { source: value } : value;
-  if (!code || Array.isArray(code) || typeof code.source !== "string" || [code.language, code.filename].some((field) => field !== void 0 && typeof field !== "string")) {
-    throw new TypeError("Code content must be a string or source object with optional string language/filename.");
-  }
-  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale;
-  if (![box.x, box.y, box.width, box.height, box.x + box.width, box.y + box.height, scale, minimum, Math.max(18 * scale, minimum) * 1.22].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || scale <= 0 || minimum <= 0) {
-    throw new RangeError("Code dimensions, scale and minimum font size must be finite and positive.");
-  }
-  if (options.overflow !== void 0 && !["warn", "error"].includes(options.overflow)) throw new RangeError("Invalid code overflow policy.");
-  const path = options.path ?? "code", inner = { x: box.x + 18, y: box.y + 18, width: box.width - 36, height: box.height - 36 };
-  const parts = [], diagnostics = [];
-  const add = (role, text, partPath, generated = false) => {
-    const requestedStyle = { fontFamily: options.fonts?.code ?? "monospace", fontWeight: role === "body" ? 400 : 700, italic: false, path: partPath };
-    const part = {
-      role,
-      path: partPath,
-      text,
-      sources: generated ? [] : [{ path: partPath, start: 0, end: text.length }],
-      generated,
-      box: { ...inner },
-      requestedFontSize: Math.max((role === "body" ? 18 : 14) * scale, minimum),
-      minFontSize: minimum,
-      requestedStyle,
-      style: resolveTextStyle({ ...requestedStyle }, options.textMeasurement)
-    };
-    parts.push(part);
-    return part;
-  };
-  if (code.filename) add("filename", code.filename, `${path}.filename`);
-  if (code.language) add("language", code.language, `${path}.language`);
-  if (!parts.length) add("language", "code", path, true);
-  const body = add("body", code.source, shorthand ? path : `${path}.source`), headers = parts.filter((part) => part !== body);
-  const usable = (area) => [area.x, area.y, area.width, area.height].every(Number.isFinite) && area.width > 0 && area.height > 0;
-  const fit = (part, area, size = part.requestedFontSize, floor = minimum) => usable(area) ? fitCodeText(part.text, area, size, floor, scale, textWidthMeasurer(part.style, options.textMeasurement)) : void 0;
-  if (usable(inner)) {
-    const combinations = headers.reduce((choices, part) => choices.flatMap((choice) => [.../* @__PURE__ */ new Set([part.requestedFontSize, minimum])].map((size) => [...choice, { part, size }])), [[]]);
-    let selected;
-    for (const combination of combinations) {
-      let y = inner.y;
-      const allocations = [];
-      for (const [index, { part, size }] of combination.entries()) {
-        const measured = fitCodeText(part.text, inner, size, size, scale, textWidthMeasurer(part.style, options.textMeasurement));
-        const area2 = { ...inner, y, height: measured.lines.length * measured.lineHeight };
-        allocations.push({ part, box: area2, fit: usable(area2) ? { ...measured, overflow: measured.sourceLines.some((line) => line.width > area2.width + 0.01) } : void 0 });
-        y += area2.height + (index < headers.length - 1 ? 8 : 12);
-      }
-      const area = { ...inner, y, height: inner.y + inner.height - y };
-      allocations.push({ part: body, box: area, fit: fit(body, area) });
-      const overflow = allocations.some(({ box: box2, fit: fit2 }) => !fit2 || fit2.overflow || !usable(box2) || box2.y + box2.height > inner.y + inner.height + 0.01);
-      const score = allocations.reduce((sum, { part, fit: fit2 }) => sum + (part.requestedFontSize - (fit2?.fontSize ?? minimum)) / scale, 0);
-      if (!selected || !overflow && (selected.overflow || score < selected.score) || overflow && selected.overflow) selected = { allocations, score, overflow };
-    }
-    if (selected) for (const { part, box: box2, fit: fit2 } of selected.allocations) {
-      part.box = box2;
-      part.fit = fit2;
-    }
-  }
-  const report = (reason, part, roles, message) => diagnostics.push({ code: "text-overflow", reason, path: part.path, parts: roles, message });
-  for (const part of parts) {
-    if (!part.fit) report("invalid-part-box", part, [part.role], `Code ${part.role} has no usable space after metadata and insets; increase the cell or change the arrangement.`);
-    else if (part.fit.overflow) report("text-fit", part, [part.role], `Code ${part.role} exceeds its space at the readability floor; increase its space or change the arrangement.`);
-    const area = part.box;
-    if (usable(area) && (area.x < box.x || area.y < box.y || area.x + area.width > box.x + box.width + 0.01 || area.y + area.height > box.y + box.height + 0.01)) {
-      report("part-outside-cell", part, [part.role], `Code ${part.role} extends outside its cell; increase the cell or change the arrangement.`);
-    }
-  }
-  for (const [index, first] of parts.entries()) {
-    const second = parts[index + 1];
-    if (first.fit && second?.fit && first.box.y + first.fit.lines.length * first.fit.lineHeight > second.box.y + 0.01) {
-      report("part-overlap", first, [first.role, second.role], "Code part line boxes overlap; do not accept this layout without more space.");
-    }
-  }
-  if (diagnostics.length && options.overflow === "error") throw new OPFCompositionError(diagnostics);
-  return { algorithm: "code-flow-v1", textMeasurement: options.textMeasurement ? "provided" : "estimated", parts, diagnostics, overflow: diagnostics.length > 0 };
-}
-function fitRichText(input, box, requestedSize = 25, minFontSize = 16, options = { style: { fontFamily: "sans-serif", fontWeight: 400 } }) {
-  if (![box.width, box.height, requestedSize, minFontSize].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("Rich text dimensions and font sizes must be finite and positive.");
-  const layout = richTextLayouter(input, box, requestedSize, options);
-  return fitAtSizes(layout, requestedSize, richMinimum(input, requestedSize, minFontSize));
-}
-function richMinimum(input, requested, minimum) {
-  let floor = Math.min(requested, minimum), visible = false;
-  for (const value of input) {
-    const run = typeof value === "string" ? { text: value } : value;
-    if (!run.text) continue;
-    const ratio = (run.fontSize === void 0 ? 1 : run.fontSize * 4 / 3 / requested) * (run.superscript || run.subscript ? 0.7 : 1);
-    floor = Math.max(floor, minimum / ratio);
-    visible = true;
-  }
-  return visible ? floor : minimum;
-}
-function richTextLayouter(input, box, requestedSize, options) {
-  let offset = 0;
-  const source = input.map((value, runIndex) => {
-    const run = typeof value === "string" ? { text: value } : value;
-    if (typeof run?.text !== "string" || run.fontSize !== void 0 && (!Number.isFinite(run.fontSize) || run.fontSize <= 0)) throw new RangeError("Rich text runs need text and a positive finite font size.");
-    const start = offset;
-    offset += run.text.length;
-    const style = resolveTextStyle({ ...options.style, fontFamily: run.fontFamily ?? options.style.fontFamily, fontWeight: run.bold === void 0 ? options.style.fontWeight : run.bold ? 700 : 400, italic: run.italic ?? options.style.italic, path: options.style.path ? `${options.style.path}.${runIndex}` : void 0 }, options.textMeasurement);
-    return { run, runIndex, start, end: offset, style };
-  });
-  const whole = source.map((entry) => entry.run.text).join("");
-  const layout = (fontSize) => {
-    const ratio = fontSize / requestedSize;
-    const fragments = (start, end) => {
-      let x = 0;
-      const result = [];
-      for (const entry of source) {
-        const a = Math.max(start, entry.start), b = Math.min(end, entry.end);
-        if (b <= a) continue;
-        const text = whole.slice(a, b), normalSize = (entry.run.fontSize !== void 0 ? entry.run.fontSize * 4 / 3 : requestedSize) * ratio;
-        const script = entry.run.superscript || entry.run.subscript;
-        const size = normalSize * (script ? 0.7 : 1), baselineShift = entry.run.superscript ? -normalSize * 0.35 : entry.run.subscript ? normalSize * 0.2 : 0;
-        const measure = textWidthMeasurer(entry.style, options.textMeasurement);
-        let cursor = 0;
-        for (const [index, segment] of text.split("	").entries()) {
-          if (index) {
-            const tabStart = a + cursor, tabWidth = measure(" ", size) * 4;
-            if (!Number.isFinite(tabWidth) || tabWidth <= 0) throw new RangeError("Rich text tabs require a positive finite measured space advance.");
-            const next = (Math.floor(x / tabWidth + 1e-9) + 1) * tabWidth;
-            result.push({ kind: "tab", text: "	", runIndex: entry.runIndex, start: tabStart - entry.start, end: tabStart - entry.start + 1, x, width: next - x, fontSize: size, baselineShift, style: entry.style, run: entry.run });
-            x = next;
-            cursor++;
-          }
-          if (segment) {
-            const width2 = measure(segment, size), segmentStart = a + cursor;
-            result.push({ text: segment, runIndex: entry.runIndex, start: segmentStart - entry.start, end: segmentStart - entry.start + segment.length, x, width: width2, fontSize: size, baselineShift, style: entry.style, run: entry.run });
-            x += width2;
-            cursor += segment.length;
-          }
-        }
-      }
-      return result;
-    };
-    const width = (start, end) => fragments(start, end).reduce((sum, fragment) => sum + fragment.width, 0);
-    const ranges = [];
-    let lineStart = 0, lineEnd = 0;
-    const push = (end) => {
-      ranges.push({ start: lineStart, end });
-      lineStart = end;
-      lineEnd = end;
-    };
-    for (const match of whole.matchAll(/\r\n|\r|\n|[^\S\r\n]+|[^\s]+/gu)) {
-      const start = match.index, end = start + match[0].length;
-      if (/^[\r\n]/.test(match[0])) {
-        push(start);
-        lineStart = end;
-        lineEnd = end;
-        continue;
-      }
-      if (width(lineStart, end) <= box.width) {
-        lineEnd = end;
-        continue;
-      }
-      if (lineEnd > lineStart) push(start);
-      if (width(start, end) <= box.width) {
-        lineEnd = end;
-        continue;
-      }
-      for (const { segment, index } of textSegments.segment(match[0])) {
-        const next = start + index + segment.length;
-        if (lineEnd > lineStart && width(lineStart, next) > box.width) push(start + index);
-        lineEnd = next;
-      }
-    }
-    ranges.push({ start: lineStart, end: lineEnd });
-    let y = 0;
-    const richLines = ranges.map((range) => {
-      const parts = fragments(range.start, range.end), ascent = Math.max(fontSize, ...parts.map((part) => part.fontSize - part.baselineShift)), descent = Math.max(fontSize * 0.22, ...parts.map((part) => part.fontSize * 0.22 + part.baselineShift));
-      const height = ascent + descent, line = { fragments: parts, width: parts.reduce((sum, p) => sum + p.width, 0), y, baseline: y + ascent, height };
-      y += height;
-      return line;
-    });
-    if (options.uniformLineHeight) {
-      const height = Math.max(...richLines.map((line) => line.height));
-      y = 0;
-      for (const line of richLines) {
-        line.baseline += y - line.y;
-        line.y = y;
-        line.height = height;
-        y += height;
-      }
-    }
-    return { lines: ranges.map((range) => whole.slice(range.start, range.end)), fontSize, lineHeight: Math.max(fontSize * 1.22, ...richLines.map((line) => line.height)), richLines, height: y, overflow: y > box.height + 0.01 || richLines.some((line) => line.width > box.width + 0.01) };
-  };
-  return layout;
-}
-function fitList(input, box, requestedSize = 25, minFontSize = 16, options = { style: { fontFamily: "sans-serif", fontWeight: 400 } }) {
-  if (!Array.isArray(input) || ![box.width, box.height, requestedSize, minFontSize].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("List content, dimensions and font sizes must be valid.");
-  const source = input.map((value, index) => {
-    const object = typeof value === "object" && !Array.isArray(value) ? value : void 0;
-    const text = object ? object.text : value, description = object?.description, level = object?.level ?? 0;
-    if (!Number.isInteger(level) || level < 0) throw new RangeError("List levels must be nonnegative integers.");
-    const runs = (value2) => typeof value2 === "string" ? [value2] : value2;
-    if (!Array.isArray(runs(text)) || description !== void 0 && !Array.isArray(runs(description))) throw new TypeError("List text and descriptions must be strings or text runs.");
-    const base = options.style.path ? `${options.style.path}.${index}` : void 0;
-    return { index, level, value: text, descriptionValue: description, textPath: base ? base + (object ? ".text" : "") : void 0, descriptionPath: base ? base + ".description" : void 0, runs: runs(text), descriptionRuns: description === void 0 ? void 0 : runs(description) };
-  });
-  const layout = (fontSize) => {
-    let y = box.y, overflow = false;
-    const entries = [], lines = [];
-    for (const item of source) {
-      const indent = fontSize * 1.1, offset = Math.min(box.width, item.level * indent), x = box.x + offset + indent, width = Math.max(1, box.x + box.width - x);
-      if (offset + indent >= box.width) overflow = true;
-      const textBox = { x, y, width, height: box.height };
-      const style = { ...options.style, path: item.textPath };
-      const text = richTextLayouter(item.runs, textBox, requestedSize, { ...options, style })(fontSize);
-      textBox.height = text.height;
-      lines.push(...text.lines);
-      y += text.height;
-      let description, descriptionBox;
-      if (item.descriptionRuns !== void 0) {
-        y += fontSize * 0.12;
-        descriptionBox = { x, y, width, height: box.height };
-        description = richTextLayouter(item.descriptionRuns, descriptionBox, requestedSize * 0.82, { ...options, style: { ...options.style, path: item.descriptionPath } })(fontSize * 0.82);
-        descriptionBox.height = description.height;
-        lines.push(...description.lines);
-        y += description.height;
-      }
-      overflow ||= text.overflow || !!description?.overflow;
-      entries.push({
-        index: item.index,
-        level: item.level,
-        value: item.value,
-        descriptionValue: item.descriptionValue,
-        textPath: item.textPath,
-        descriptionPath: item.descriptionPath,
-        text,
-        textBox,
-        description,
-        descriptionBox,
-        marker: { text: ["\u2022", "\u25E6", "\u25AA"][item.level % 3], x: box.x + offset, y: textBox.y + (text.richLines[0]?.baseline ?? fontSize), fontSize, style: resolveTextStyle(style, options.textMeasurement), indent }
-      });
-      if (item.index < source.length - 1) y += fontSize * 0.28;
-    }
-    const height = y - box.y;
-    return { listEntries: entries, lines, fontSize, lineHeight: fontSize * 1.22, height, overflow: overflow || height > box.height + 0.01 };
-  };
-  let minimum = minFontSize;
-  for (const item of source) {
-    minimum = Math.max(minimum, richMinimum(item.runs, requestedSize, minFontSize));
-    if (item.descriptionRuns !== void 0) minimum = Math.max(minimum, richMinimum(item.descriptionRuns, requestedSize * 0.82, minFontSize) / 0.82);
-  }
-  return fitAtSizes(layout, requestedSize, minimum);
-}
-function contentText(field, value) {
-  if (field === "text" || headings.has(field)) return flatten(value);
-  if (field === "items" || field === "bullets") return (Array.isArray(value) ? value : [value]).map((item) => {
-    const entry = record2(item);
-    return `\u2022 ${flatten(item)}${entry.description ? `
-${flatten(entry.description)}` : ""}`;
-  }).join("\n");
-  if (field === "code") return flatten(record2(value).source ?? value);
-  if (field === "quote") return flatten(record2(value).text ?? value);
-  return void 0;
-}
-function layoutTable(value, box, options = {}) {
-  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale, requested = Math.max(15 * scale, minimum);
-  if (![box.x, box.y, box.width, box.height, scale, minimum].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || scale <= 0 || minimum <= 0) throw new RangeError("Table dimensions, scale and font sizes must be finite and positive.");
-  const grid = tableGrid(value, options.path ?? "table");
-  if (grid.issues.length) throw new RangeError(`${grid.issues[0].path}: ${grid.issues[0].message}`);
-  const columnCount = grid.columnCount, cellWidth = box.width / columnCount;
-  const cells = grid.rows.flat().map((cell) => {
-    const padding = { top: 8, right: 10, bottom: 4, left: 10, ...cell.style.padding };
-    const width = cellWidth * cell.colSpan - (padding.left + padding.right) * scale;
-    const style = { fontFamily: options.fontFamily ?? "sans-serif", fontWeight: cell.header ? 700 : 400, italic: false, path: cell.valuePath };
-    return { ...cell, padding, width, textStyle: style };
-  });
-  const cellMinimum = (cell) => Array.isArray(cell.value) ? richMinimum(cell.value, requested, minimum) : minimum;
-  const fitCell = (cell, height, min) => {
-    const textBox = { width: Math.max(scale, cell.width), height: Math.max(scale, height) };
-    return Array.isArray(cell.value) ? fitRichText(cell.value, textBox, requested, min, { style: cell.textStyle, textMeasurement: options.textMeasurement, uniformLineHeight: true }) : fitText(flatten(cell.value), textBox, requested, min, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement));
-  };
-  const textHeight = (fit) => "height" in fit ? fit.height : fit.lines.length * fit.lineHeight;
-  const required = (cell, natural2) => {
-    const floor = cellMinimum(cell), size = natural2 ? Math.max(requested, floor) : floor;
-    const textBox = { width: Math.max(scale, cell.width), height: scale };
-    const fit = Array.isArray(cell.value) ? richTextLayouter(cell.value, textBox, requested, { style: cell.textStyle, textMeasurement: options.textMeasurement, uniformLineHeight: true })(size) : fitText(flatten(cell.value), textBox, size, size, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement));
-    return textHeight(fit) + (cell.padding.top + cell.padding.bottom) * scale;
-  };
-  const natural = Array(grid.rowCount).fill(0), needed = Array(grid.rowCount).fill(0);
-  for (const cell of cells) if (cell.rowSpan === 1) {
-    natural[cell.row] = Math.max(natural[cell.row], required(cell, true));
-    needed[cell.row] = Math.max(needed[cell.row], required(cell, false));
-  }
-  for (const cell of cells) if (cell.rowSpan > 1) for (const [heights2, preferredSize] of [[natural, true], [needed, false]]) {
-    const current = heights2.slice(cell.row, cell.row + cell.rowSpan).reduce((a, b) => a + b, 0);
-    const extra = Math.max(0, required(cell, preferredSize) - current) / cell.rowSpan;
-    for (let r = cell.row; r < cell.row + cell.rowSpan; r++) heights2[r] += extra;
-  }
-  const preferred = natural.map((height) => Math.max(54 * scale, height));
-  for (let r = 0; r < needed.length; r++) needed[r] = Math.min(preferred[r], needed[r]);
-  const sum = (values) => values.reduce((a, b) => a + b, 0);
-  const preferredTotal = sum(preferred), naturalTotal = sum(natural), neededTotal = sum(needed);
-  const heights = preferred.map((height, r) => preferredTotal <= box.height ? height : naturalTotal <= box.height ? natural[r] + (height - natural[r]) * (box.height - naturalTotal) / Math.max(Number.EPSILON, preferredTotal - naturalTotal) : neededTotal <= box.height ? needed[r] + (natural[r] - needed[r]) * (box.height - neededTotal) / Math.max(Number.EPSILON, naturalTotal - neededTotal) : needed[r] * box.height / neededTotal);
-  const ys = [box.y];
-  for (const height of heights) ys.push(ys.at(-1) + height);
-  let overflow = false;
-  const rows2 = heights.map((height, r) => ({ box: { x: box.x, y: ys[r], width: box.width, height }, cells: [] }));
-  for (const cell of cells) {
-    const cellBox = { x: box.x + cell.column * cellWidth, y: ys[cell.row], width: cell.colSpan * cellWidth, height: ys[cell.row + cell.rowSpan] - ys[cell.row] };
-    const available = cellBox.height - (cell.padding.top + cell.padding.bottom) * scale;
-    const fit = fitCell(cell, available, minimum), height = textHeight(fit);
-    const offset = cell.style.verticalAlign === "bottom" ? Math.max(0, available - height) : cell.style.verticalAlign === "middle" ? Math.max(0, (available - height) / 2) : 0;
-    const textBox = { x: cellBox.x + cell.padding.left * scale, y: cellBox.y + cell.padding.top * scale + offset, width: Math.max(scale, cell.width), height: Math.max(scale, available - offset) };
-    overflow ||= cell.width <= 0 || available <= 0 || fit.overflow;
-    rows2[cell.row].cells.push({ value: cell.value, input: cell.input, path: cell.valuePath, sourcePath: cell.path, style: cell.style, row: cell.row, column: cell.column, rowSpan: cell.rowSpan, colSpan: cell.colSpan, header: cell.header, rich: Array.isArray(cell.value), box: cellBox, textBox, textStyle: resolveTextStyle(cell.textStyle, options.textMeasurement), fit });
-  }
-  return { rows: rows2, columnCount, height: sum(heights), overflow };
-}
-function tableOverflows(value, box, scale, settings, options, path) {
-  return box.width <= 0 || box.height <= 0 || layoutTable(value, box, { scale, minFontSize: settings.minFontSize, fontFamily: options.fonts?.body, textMeasurement: options.textMeasurement, path }).overflow;
-}
-function flatten(value) {
-  if (value == null) return "";
-  if (typeof value !== "object") return String(value);
-  if (Array.isArray(value)) return value.map(flatten).join("");
-  const item = record2(value);
-  return flatten(item.text ?? item.value ?? item.source ?? JSON.stringify(value));
-}
-function regionParts(key) {
-  const span = (part, order) => {
-    const indices = part.split("+").map((value) => order.indexOf(value));
-    return indices.every((index) => index >= 0) ? indices : void 0;
-  };
-  const parts = key.split(":");
-  if (parts.length === 2) {
-    const r = span(parts[0], rows), c = span(parts[1], columns);
-    if (r && c) return [r, c];
-  } else if (parts.length === 1) {
-    const r = span(key, rows), c = span(key, columns);
-    if (r) return [r, [0, 1, 2]];
-    if (c) return [[0, 1, 2], c];
-  }
-  return void 0;
-}
-function regionBox(parts, area, requestedGap) {
-  const gap = Math.min(requestedGap, area.width / 6, area.height / 6);
-  const cw = (area.width - gap * 2) / 3, ch = (area.height - gap * 2) / 3;
-  const [r, c] = parts;
-  return { x: area.x + Math.min(...c) * (cw + gap), y: area.y + Math.min(...r) * (ch + gap), width: (Math.max(...c) - Math.min(...c) + 1) * (cw + gap) - gap, height: (Math.max(...r) - Math.min(...r) + 1) * (ch + gap) - gap };
-}
-function gridGeometry(count, area, cols, gap, weights, vertical) {
-  const rowCount = Math.ceil(count / cols);
-  gap = Math.min(gap, area.width / (cols * 2), area.height / (rowCount * 2));
-  const tracks = (length, total, weighted) => {
-    const values = Array.from({ length }, (_, i) => weighted ? weights[i] ?? 1 : 1);
-    const sum = values.reduce((a, b) => a + b, 0);
-    let cursor = 0;
-    return values.map((weight) => {
-      const size = (total - gap * (length - 1)) * weight / sum;
-      const track = { offset: cursor, size };
-      cursor += size + gap;
-      return track;
-    });
-  };
-  const xs = tracks(cols, area.width, !vertical), ys = tracks(rowCount, area.height, vertical);
-  const boxes = Array.from({ length: count }, (_, i) => ({ x: area.x + xs[i % cols].offset, y: area.y + ys[Math.floor(i / cols)].offset, width: xs[i % cols].size, height: ys[Math.floor(i / cols)].size }));
-  return { boxes, columns: xs, rows: ys, gap };
-}
-function gridBoxes(count, area, cols, gap, weights, vertical) {
-  return gridGeometry(count, area, cols, gap, weights, vertical).boxes;
-}
-function assertComposition(value) {
-  if (value.mode !== void 0 && !["auto", "grid", "row", "column"].includes(value.mode)) throw new RangeError("Unknown composition mode.");
-  for (const [key, min, max] of [["gap", 0, 0.1], ["padding", 0, 0.2], ["minFontSize", 8, 32], ["columns", 1, 12]]) {
-    const number = value[key];
-    if (number !== void 0 && (!Number.isFinite(number) || number < min || number > max || key === "columns" && !Number.isInteger(number))) throw new RangeError(`Invalid composition.${key}.`);
-  }
-  if (value.weights !== void 0 && (!Array.isArray(value.weights) || !value.weights.length || value.weights.length > 12 || value.weights.some((weight) => !Number.isFinite(weight) || weight <= 0 || weight > 100))) throw new RangeError("Invalid composition.weights.");
-  if (value.overflow !== void 0 && !["warn", "error"].includes(value.overflow)) throw new RangeError("Invalid composition.overflow.");
-}
-function composeSlide(input, options = {}) {
-  const slide = record2(input), layout = record2(options.layout);
-  const width = options.width ?? 1280, height = options.height ?? 720;
-  if (![width, height].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("Canvas dimensions must be finite and positive.");
-  const scale = Math.min(width, height) / 720;
-  const hasCards = record2(slide.design).contentBox ?? options.contentBox ?? false;
-  const composition = { ...record2(layout.composition), ...record2(slide.composition) };
-  assertComposition(composition);
-  const padding = (composition.padding ?? 0.08) * Math.min(width, height);
-  const gap = (composition.gap ?? 1 / 30) * Math.min(width, height);
-  const minSize = (composition.minFontSize ?? 16) * scale;
-  const rasterPadding = (options.textRasterPadding ?? 1) * scale;
-  if (!Number.isFinite(rasterPadding) || rasterPadding < 0) throw new RangeError("Text raster padding must be finite and nonnegative.");
-  const alignmentFor = (field) => (field === "title" ? record2(slide.design).titleAlignment ?? options.titleAlignment : record2(slide.design).contentAlignment ?? options.contentAlignment) ?? "left";
-  const styleFor = (field, path2) => resolveTextStyle({
-    fontFamily: (field === "title" ? options.fonts?.heading : field === "code" ? options.fonts?.code : options.fonts?.body) ?? (field === "code" ? "monospace" : "sans-serif"),
-    fontWeight: field === "title" ? 700 : 400,
-    path: path2
-  }, options.textMeasurement);
-  const widthFor = (field, path2) => textWidthMeasurer(styleFor(field, path2), options.textMeasurement);
-  const fitPlacedText = (field, value, text, box, size, minimum, path2) => {
-    const style = styleFor(field, path2), rich = field === "text" && Array.isArray(value);
-    if (!options.textMeasurement?.outlineBounds) return rich ? fitRichText(value, box, size, minimum, { style, textMeasurement: options.textMeasurement }) : fitText(text, box, size, minimum, textWidthMeasurer(style, options.textMeasurement));
-    const alignment = alignmentFor(field);
-    const richLayout = rich ? richTextLayouter(value, box, size, { style, textMeasurement: options.textMeasurement }) : void 0;
-    const measure = textWidthMeasurer(style, options.textMeasurement), floor = rich ? richMinimum(value, size, minimum) : minimum, start = Math.max(size, floor);
-    for (let trial = 0; trial <= 64; trial++) {
-      const fontSize = trial === 64 ? floor : Math.max(floor, start - trial * scale);
-      const fit = richLayout ? richLayout(fontSize) : fitText(text, box, fontSize, fontSize, measure);
-      const richLines = "richLines" in fit ? fit.richLines : void 0;
-      const lines = richLines ? richLines.map((line) => {
-        let outline = null;
-        for (const fragment of line.fragments) {
-          if (fragment.kind === "tab") continue;
-          const bounds = measureTextOutline(fragment.text, fragment.fontSize, fragment.style, options.textMeasurement);
-          if (!bounds) continue;
-          const next = { ...bounds, x: fragment.x + bounds.x, y: fragment.baselineShift + bounds.y };
-          if (!outline) outline = next;
-          else {
-            const right = Math.max(outline.x + outline.width, next.x + next.width), bottom = Math.max(outline.y + outline.height, next.y + next.height);
-            outline.x = Math.min(outline.x, next.x);
-            outline.y = Math.min(outline.y, next.y);
-            outline.width = right - outline.x;
-            outline.height = bottom - outline.y;
-          }
-        }
-        return { width: line.width, y: line.y, baseline: line.baseline, height: line.height, outline };
-      }) : fit.sourceLines.map((line, index) => {
-        let outline = null;
-        for (const segment of line.segments) {
-          if (segment.kind === "tab") continue;
-          const bounds = measureTextOutline(text.slice(segment.start, segment.end), fontSize, style, options.textMeasurement);
-          if (!bounds) continue;
-          const next = { ...bounds, x: segment.x + bounds.x };
-          if (!outline) outline = next;
-          else {
-            const right = Math.max(outline.x + outline.width, next.x + next.width), bottom = Math.max(outline.y + outline.height, next.y + next.height);
-            outline.x = Math.min(outline.x, next.x);
-            outline.y = Math.min(outline.y, next.y);
-            outline.width = right - outline.x;
-            outline.height = bottom - outline.y;
-          }
-        }
-        return { width: line.width, y: index * fit.lineHeight, baseline: fontSize + index * fit.lineHeight, height: fit.lineHeight, outline };
-      });
-      const placement = placeTextLines(lines, box, alignment, rasterPadding), result = { ...fit, placement, overflow: fit.overflow || placement.overflow };
-      if (!result.overflow || fontSize === floor) return result;
-    }
-    throw new Error("Text placement did not evaluate its bounded floor trial.");
-  };
-  const fitContent = (field, value, text, box, size, minimum, path2) => field === "text" ? fitPlacedText(field, value, text, box, size, minimum, path2) : field === "items" || field === "bullets" ? fitList(value, box, size, minimum, { style: styleFor(field, path2), textMeasurement: options.textMeasurement }) : fitText(text, box, size, minimum, widthFor(field, path2));
-  const path = `slides.${options.slideIndex ?? 0}`;
-  const slideImageDiagnostics = [];
-  const slideImage = resolveSlideImage(slide, layout, options.presentation, width, height, path, padding, scale, slideImageDiagnostics);
-  const area = { left: 0, top: 0, right: width, bottom: height };
-  if (slideImage?.position === "left") area.left = slideImage.region.width;
-  else if (slideImage?.position === "right") area.right = slideImage.region.x;
-  else if (slideImage?.position === "top") area.top = slideImage.region.height;
-  else if (slideImage?.position === "bottom") area.bottom = slideImage.region.y;
-  const items = [], diagnostics = [];
-  const measuredFurniture = layoutFurniture(slide, options);
-  const furniture = measuredFurniture.configured || measuredFurniture.diagnostics.length ? measuredFurniture : void 0;
-  if (furniture) diagnostics.push(...furniture.diagnostics);
-  const bodyBottom = Math.min(area.bottom - padding, furniture && furniture.footerTop < height ? furniture.footerTop - gap * 0.5 : height - padding);
-  const headingTop = Math.max(area.top + padding, furniture?.headerBottom ? furniture.headerBottom + gap * 0.5 : padding);
-  const layoutPlaceholders = Array.isArray(layout.placeholders) ? layout.placeholders : [];
-  const headingOnlyLayout = COVER_LAYOUT_IDS.has(String(layout.id ?? "")) || layoutPlaceholders.length > 0 && layoutPlaceholders.every((placeholder) => headings.has(placeholder.type ?? ""));
-  const regions = Object.keys(slide).filter((key) => regionParts(key)).sort();
-  const emptyPayload = (value) => value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
-  const emptyHost = (host) => emptyPayload(host.blocks) && fields.every((field) => emptyPayload(host[field]));
-  const hasBodyPayload = regions.some((key) => !emptyHost(record2(slide[key]))) || !emptyPayload(slide.blocks) || fields.some((field) => !emptyPayload(slide[field]));
-  const isCover = !hasBodyPayload && (headingOnlyLayout || !layout.id && !layoutPlaceholders.some((placeholder) => !headings.has(placeholder.type ?? "")));
-  let y = headingTop;
-  const headingItems = [];
-  for (const field of ["tag", "title", "subtitle"]) {
-    if (!slide[field]) continue;
-    const requested = (field === "title" ? 54 : field === "tag" ? 16 : 25) * scale;
-    const maxHeight = Math.max(height * (field === "title" ? 0.26 : field === "subtitle" ? 0.12 : 0.045), minSize * 1.22 + 2 * rasterPadding);
-    const box = { x: area.left + padding, y, width: area.right - area.left - padding * 2, height: maxHeight };
-    const text = fitPlacedText(field, slide[field], String(slide[field]), box, requested, minSize, `${path}.${field}`);
-    box.height = Math.min(maxHeight, Math.max(text.lines.length * text.lineHeight, text.placement?.height ?? 0));
-    if (furniture && box.y + box.height > bodyBottom + 0.01) diagnostics.push({ code: "text-overflow", path: `${path}.${field}`, message: "Repeated furniture leaves too little room for this heading. Change the header/footer or slide design." });
-    const item = { path: `${path}.${field}`, field, type: "text", value: slide[field], payload: { text: slide[field] }, box, text, textStyle: styleFor(field, `${path}.${field}`), composition, alignment: alignmentFor(field) };
-    headingItems.push(item);
-    items.push(item);
-    y += box.height + gap * 0.5;
-  }
-  if (headingItems.length) {
-    if (isCover) {
-      const last = headingItems[headingItems.length - 1];
-      const shift = Math.max(0, (bodyBottom - (last.box.y + last.box.height)) / 2);
-      if (shift) for (const item of headingItems) {
-        item.box.y += shift;
-        if (item.text) item.text = translateTextFit(item.text, shift);
-      }
-      y = last.box.y + last.box.height + gap;
-    } else y += gap * 0.5;
-  }
-  const contentBox = { x: area.left + padding, y, width: area.right - area.left - padding * 2, height: Math.max(scale, bodyBottom - y) };
-  const collect = (host, basePath, depth = 0, ancestors = []) => {
-    if (Array.isArray(host.blocks)) {
-      if (depth >= MAX_COMPOSITION_DEPTH || ancestors.includes(host)) throw new RangeError(`Content groups must be acyclic and nest at most ${MAX_COMPOSITION_DEPTH} levels.`);
-      const settings = record2(host.composition);
-      assertComposition(settings);
-      return [{
-        field: "blocks",
-        type: "group",
-        value: host.blocks,
-        path: basePath,
-        payload: host,
-        composition: settings,
-        children: host.blocks.flatMap((block, index) => collect(record2(block), `${basePath}.blocks.${index}`, depth + 1, [...ancestors, host]))
-      }];
-    }
-    return fields.filter((field) => host[field] !== void 0).map((field) => ({ field, type: host.type ?? kind(field), value: host[field], path: `${basePath}.${field}`, payload: { type: host.type ?? kind(field), [field]: host[field] } }));
-  };
-  const pending = regions.length ? regions.flatMap((key) => collect(record2(slide[key]), `${path}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => collect(record2(block), `${path}.blocks.${index}`)) : collect(slideImage?.replacesContent ? { ...slide, image: void 0 } : slide, path);
-  const groups = [], flows = [];
-  const decisions = options.explain ? [] : void 0;
-  const inheritedSettings = (parent, own = {}) => ({
-    minFontSize: parent.minFontSize,
-    ...own,
-    overflow: parent.overflow === "error" ? "error" : own.overflow ?? parent.overflow
-  });
-  const inset = (box, settings) => {
-    const amount = (settings.padding ?? 0) * Math.min(box.width, box.height);
-    return { x: box.x + amount, y: box.y + amount, width: box.width - amount * 2, height: box.height - amount * 2 };
-  };
-  const acceptedBox = (box) => ({ x: round(box.x), y: round(box.y), width: round(box.width), height: round(box.height) });
-  const payloadBox = (box) => {
-    if (!hasCards) return box;
-    const frame = acceptedBox(box), padding2 = Math.min(12 * scale, frame.width / 4, frame.height / 4);
-    return acceptedBox({ x: frame.x + padding2, y: frame.y + padding2, width: frame.width - 2 * padding2, height: frame.height - 2 * padding2 });
-  };
-  const measureQuote = (node, box, settings) => layoutQuote(node.value, acceptedBox(box), {
-    fonts: options.fonts,
-    textMeasurement: options.textMeasurement,
-    scale,
-    minFontSize: settings.minFontSize,
-    path: node.path
-  });
-  const measureCode = (node, box, settings) => layoutCode(node.value, acceptedBox(box), {
-    fonts: options.fonts,
-    textMeasurement: options.textMeasurement,
-    scale,
-    minFontSize: settings.minFontSize,
-    path: node.path
-  });
-  const measureMetric = (node, box, settings) => layoutMetric(node.value, acceptedBox(box), {
-    fonts: options.fonts,
-    textMeasurement: options.textMeasurement,
-    scale,
-    minFontSize: settings.minFontSize,
-    path: node.path,
-    textRasterPadding: options.textRasterPadding,
-    align: alignmentFor("metric")
-  });
-  const measureTimeline = (node, box, settings) => layoutTimeline(node.value, acceptedBox(box), {
-    fonts: options.fonts,
-    textMeasurement: options.textMeasurement,
-    scale,
-    minFontSize: settings.minFontSize,
-    path: node.path,
-    textRasterPadding: options.textRasterPadding
-  });
-  const leafScore = (node, box, settings, penalties) => {
-    box = payloadBox(box);
-    const text = contentText(node.field, node.value);
-    let score = Math.abs(Math.log(box.width / box.height / 1.6));
-    if (penalties) penalties.cellProportions += score;
-    if (node.field === "quote" || node.field === "code" || node.field === "metric" || node.field === "timeline") {
-      const internal = node.field === "quote" ? measureQuote(node, box, settings) : node.field === "code" ? measureCode(node, box, settings) : node.field === "metric" ? measureMetric(node, box, settings) : measureTimeline(node, box, settings);
-      const reduction = internal.parts.reduce((sum, part) => sum + (part.fit ? (part.requestedFontSize - part.fit.fontSize) / scale : 0), 0);
-      score += reduction + (internal.overflow ? 1e3 : 0);
-      if (penalties) {
-        penalties.fontReduction += reduction;
-        penalties.textOverflow += internal.overflow ? 1e3 : 0;
-      }
-    } else if (text) {
-      const fit = fitContent(node.field, node.value, text, box, 25 * scale, (settings.minFontSize ?? 16) * scale, node.path);
-      const reduction = Math.max(0, 25 * scale - fit.fontSize) / scale;
-      score += reduction + (fit.overflow ? 1e3 : 0);
-      if (penalties) {
-        penalties.fontReduction += reduction;
-        penalties.textOverflow += fit.overflow ? 1e3 : 0;
-      }
-    }
-    if (node.field === "table" && tableOverflows(node.value, box, scale, settings, options, node.path)) {
-      score += 1e3;
-      if (penalties) penalties.tableOverflow += 1e3;
-    }
-    if (box.width < 100 * scale || box.height < 60 * scale) {
-      score += 100;
-      if (penalties) penalties.smallCells += 100;
-    }
-    return score;
-  };
-  const modeFor = (settings) => settings.mode ?? "auto";
-  const defaultColumns = (count, area2, settings) => {
-    const mode = modeFor(settings);
-    return mode === "column" ? 1 : mode === "row" ? Math.max(1, count) : settings.columns ?? Math.max(1, Math.min(count, Math.ceil(Math.sqrt(count * area2.width / area2.height / 1.6))));
-  };
-  const scoreNode = (node, box, settings, penalties) => {
-    if (!node.children) return leafScore(node, box, settings, penalties);
-    const own = inheritedSettings(settings, node.composition), area2 = inset(box, own);
-    const cols = defaultColumns(node.children.length, area2, own);
-    const boxes = gridBoxes(node.children.length, area2, cols, (own.gap ?? 1 / 30) * Math.min(box.width, box.height), own.weights ?? [], modeFor(own) === "column");
-    return node.children.reduce((score, child, index) => score + scoreNode(child, boxes[index], own, penalties), 0);
-  };
-  const arrange = (nodes, area2, settings, reserved = 0, gapOverride, containerPath = path) => {
-    const count = Math.max(nodes.length, reserved);
-    if (!count) return;
-    const mode = modeFor(settings), localGap = (settings.gap ?? 1 / 30) * Math.min(area2.width, area2.height);
-    const actualGap = gapOverride ?? (settings === rootSettings ? gap : localGap);
-    let cols = defaultColumns(count, area2, settings);
-    const hasRegions = nodes.some((node) => node.region);
-    const candidates = decisions ? [] : void 0;
-    if (mode === "auto" && !hasRegions) {
-      let best = Infinity;
-      for (let candidate = 1; candidate <= Math.min(count, settings.columns ?? 6); candidate++) {
-        const boxes2 = gridBoxes(count, area2, candidate, actualGap, settings.weights ?? [], false);
-        const emptySlots = (Math.ceil(count / candidate) * candidate - count) * 2;
-        const penalties = candidates ? { cellProportions: 0, fontReduction: 0, textOverflow: 0, tableOverflow: 0, smallCells: 0, emptySlots } : void 0;
-        const score = nodes.reduce((sum, node, i) => sum + scoreNode(node, boxes2[i], settings, penalties), 0) + emptySlots;
-        if (penalties && candidates) candidates.push({ columns: candidate, rows: Math.ceil(count / candidate), score, penalties });
-        if (score < best) {
-          best = score;
-          cols = candidate;
-        }
-      }
-    }
-    decisions?.push({
-      path: containerPath,
-      mode: hasRegions ? "regions" : mode,
-      reason: hasRegions ? "promoted-regions" : mode === "auto" ? "lowest-score" : "configured-mode",
-      ...hasRegions ? {} : { selectedColumns: cols },
-      candidates: candidates ?? []
-    });
-    const grid = gridGeometry(count, area2, cols, actualGap, settings.weights ?? [], mode === "column");
-    const boxes = grid.boxes;
-    if (!nodes.some((node) => node.region)) flows.push({ path: containerPath, box: { ...area2 }, composition: { ...settings }, columns: grid.columns, rows: grid.rows, gap: grid.gap, itemCount: nodes.length, slotCount: count });
-    nodes.forEach((node, index) => {
-      let box = node.region ? regionBox(node.region, area2, actualGap) : boxes[index];
-      if (node.children) {
-        const own = inheritedSettings(settings, node.composition), inner = inset(box, own);
-        groups.push({ path: node.path, box, contentBox: inner, composition: own });
-        arrange(node.children, inner, own, 0, (own.gap ?? 1 / 30) * Math.min(box.width, box.height), node.path);
-      } else {
-        const frameBox = hasCards ? acceptedBox(box) : void 0;
-        box = payloadBox(box);
-        const textValue = contentText(node.field, node.value);
-        const quoteLayout = node.field === "quote" ? measureQuote(node, box, settings) : void 0;
-        const codeLayout = node.field === "code" ? measureCode(node, box, settings) : void 0;
-        const metricLayout = node.field === "metric" ? measureMetric(node, box, settings) : void 0;
-        const timelineLayout = node.field === "timeline" ? measureTimeline(node, box, settings) : void 0;
-        const internal = quoteLayout ?? codeLayout ?? metricLayout ?? timelineLayout, body = internal?.parts.find((part) => part.role === "body" || part.role === "value");
-        const text = internal ? body?.fit : textValue !== void 0 ? fitContent(node.field, node.value, textValue, box, 25 * scale, (settings.minFontSize ?? 16) * scale, node.path) : void 0;
-        items.push({
-          path: node.path,
-          field: node.field,
-          type: node.type,
-          value: node.value,
-          payload: node.payload,
-          box: internal ? acceptedBox(box) : box,
-          ...frameBox ? { frameBox } : {},
-          text,
-          textStyle: body?.style ?? styleFor(node.field, node.path),
-          composition: settings,
-          alignment: alignmentFor(node.field),
-          ...quoteLayout ? { quoteLayout } : {},
-          ...codeLayout ? { codeLayout } : {},
-          ...metricLayout ? { metricLayout } : {},
-          ...timelineLayout ? { timelineLayout } : {}
-        });
-        if (box.width < 100 * scale || box.height < 60 * scale) diagnostics.push({ code: "small-cell", path: node.path, message: "Content cell is too small for comfortable reading; use fewer blocks or a different composition." });
-      }
-    });
-  };
-  const placeholders = Array.isArray(layout.placeholders) ? layout.placeholders.filter((p) => !headings.has(p.type)) : [];
-  if (slideImage?.replacesContent) {
-    const picture = placeholders.findIndex((p) => p.type === "picture");
-    if (picture >= 0) placeholders.splice(picture, 1);
-  }
-  const rootSettings = { ...composition, mode: composition.mode ?? (layout.slideLayoutDirection === "Vertical" ? "column" : layout.slideLayoutDirection === "Horizontal" ? "row" : "auto") };
-  arrange(pending, contentBox, rootSettings, composition.mode ? 0 : placeholders.length);
-  for (const item of items) {
-    for (const key of ["x", "y", "width", "height"]) item.box[key] = round(item.box[key]);
-    if (item.field === "table" && tableOverflows(item.value, item.box, scale, item.composition, options, item.path)) diagnostics.push({ code: "text-overflow", path: item.path, message: "Table cells do not fit; use fewer rows, fewer columns, or split the table across slides." });
-    if (item.quoteLayout) diagnostics.push(...item.quoteLayout.diagnostics);
-    else if (item.codeLayout) diagnostics.push(...item.codeLayout.diagnostics);
-    else if (item.metricLayout) diagnostics.push(...item.metricLayout.diagnostics);
-    else if (item.timelineLayout) diagnostics.push(...item.timelineLayout.diagnostics);
-    else if (item.text?.overflow) diagnostics.push({ code: "text-overflow", path: item.path, message: "Text exceeds its cell at the minimum font size; shorten it, increase its space, or split the slide." });
-  }
-  for (const group of groups) for (const box of [group.box, group.contentBox]) for (const key of ["x", "y", "width", "height"]) box[key] = round(box[key]);
-  const strictPaths = new Set(items.filter((item) => item.composition.overflow === "error").map((item) => item.path));
-  const failures = diagnostics.filter((diagnostic) => {
-    if (composition.overflow === "error") return true;
-    let path2 = diagnostic.path;
-    while (path2) {
-      if (strictPaths.has(path2)) return true;
-      const boundary = path2.lastIndexOf(".");
-      if (boundary < 0) break;
-      path2 = path2.slice(0, boundary);
-    }
-    return false;
-  });
-  const explanation = decisions ? {
-    algorithm: "grid-score-v9",
-    textMeasurement: options.textMeasurement ? "provided" : "estimated",
-    textOutlines: options.textMeasurement?.outlineBounds ? "provided" : "unavailable",
-    textRasterPadding: rasterPadding,
-    decisions,
-    unmeasuredPayloads: items.filter((item) => !headings.has(item.field) && !item.quoteLayout && !item.codeLayout && !item.metricLayout && !item.timelineLayout && !["text", "items", "bullets", "table"].includes(item.field)).map((item) => item.path)
-  } : void 0;
-  if (failures.length) throw new OPFCompositionError(failures, explanation);
-  diagnostics.push(...slideImageDiagnostics);
-  return { width, height, contentBox, items, groups, flows, diagnostics, composition, ...furniture ? { furniture } : {}, ...slideImage ? { slideImage } : {}, ...explanation ? { explanation } : {} };
-}
-function resolveCanvasDimensions(input) {
-  const presets = {
-    widescreen: [40 / 3, 7.5],
-    "16:9": [40 / 3, 7.5],
-    standard: [10, 7.5],
-    "4:3": [10, 7.5],
-    "16:10": [10, 6.25],
-    letter: [11, 8.5],
-    a4: [11.69, 8.27]
-  };
-  const value = record2(input);
-  const preset = presets[typeof input === "string" ? input : value.preset] ?? presets.widescreen;
-  const width = (value.widthInches ?? preset[0]) * 96;
-  const height = (value.heightInches ?? preset[1]) * 96;
-  if (![width, height].every((n) => Number.isFinite(n) && n > 0)) throw new RangeError("Canvas dimensions must be finite and positive.");
-  return { width, height };
-}
-
-export { DEFAULT_FONT_SCHEME, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_SLIDE_NUMBER_FORMAT, MAX_COMPOSITION_DEPTH, OPFCompositionError, chartColorForFill, colorContrast, composeSlide, fitList, fitRichText, fitText, formatFurnitureDate, formatSlideNumber, layoutCode, layoutFurniture, layoutMetric, layoutQuote, layoutTable, layoutTimeline, measureText, measureTextOutline, normalizeHexColor, placeTextLines, resolveCanvasDimensions, resolveColorRef, resolveFontFamilies, resolveFontSchemeReference, resolveSocialProfile, resolveTextStyle, slideImageShape, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, wrapText };