@openpresentation/opf 0.3.0 → 0.4.0

package/dist/chunk-HJNJHB5H.js

@@ -0,0 +1,454 @@
+// src/composition.ts
+var MAX_COMPOSITION_DEPTH = 32;
+function resolveFontFamilies(input) {
+  const scheme = record(input);
+  const family = (value) => typeof value === "string" ? value : record(value).family;
+  return {
+    heading: family(scheme.heading) ?? scheme.major ?? scheme.minor ?? "Roboto",
+    body: family(scheme.body) ?? scheme.minor ?? scheme.major ?? "Roboto",
+    code: family(scheme.code) ?? "Roboto Mono"
+  };
+}
+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;
+  };
+}
+var OPFCompositionError = class extends Error {
+  constructor(diagnostics) {
+    super("Slide content does not fit its composition.");
+    this.diagnostics = diagnostics;
+    this.name = "OPFCompositionError";
+  }
+  diagnostics;
+  code = "layout-overflow";
+};
+var fields = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
+var headings = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
+var rows = ["top", "middle", "bottom"];
+var columns = ["left", "center", "right"];
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var kind = (field) => field === "items" || field === "bullets" ? "list" : field;
+var round = (value) => Math.round(value * 1e6) / 1e6 || value;
+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) {
+  const result = [];
+  for (const paragraph of text.replace(/\r\n?/g, "\n").split("\n")) {
+    let line = "";
+    for (const word of paragraph.split(/\s+/u).filter(Boolean)) {
+      if (line && measure(`${line} ${word}`, fontSize) > width) {
+        result.push(line);
+        line = "";
+      }
+      if (measure(word, fontSize) <= width) {
+        line += (line ? " " : "") + word;
+        continue;
+      }
+      for (const { segment: character } of textSegments.segment(word)) {
+        if (line && measure(line + character, fontSize) > width) {
+          result.push(line);
+          line = "";
+        }
+        line += character;
+      }
+    }
+    result.push(line);
+  }
+  return result;
+}
+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.");
+  }
+  const minimum = Math.min(minFontSize, requestedSize);
+  let fontSize = requestedSize;
+  let lines = wrapText(text, box.width, fontSize, measure);
+  while (fontSize > minimum && (lines.length * fontSize * 1.22 > box.height || lines.some((line) => measure(line, fontSize) > box.width))) {
+    fontSize = Math.max(minimum, fontSize - 1);
+    lines = wrapText(text, box.width, fontSize, measure);
+  }
+  return { lines, fontSize, lineHeight: fontSize * 1.22, overflow: lines.length * fontSize * 1.22 > box.height + 0.01 || lines.some((line) => measure(line, fontSize) > box.width + 0.01) };
+}
+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), minimum = Math.min(requestedSize, minFontSize);
+  let size = requestedSize, result = layout(size);
+  while (result.overflow && size > minimum) {
+    size = Math.max(minimum, size - 1);
+    result = layout(size);
+  }
+  return result;
+}
+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 width2 = textWidthMeasurer(entry.style, options.textMeasurement)(text, size);
+        result.push({ text, runIndex: entry.runIndex, start: a - entry.start, end: b - entry.start, x, width: width2, fontSize: size, baselineShift, style: entry.style, run: entry.run });
+        x += width2;
+      }
+      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;
+    });
+    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 };
+  };
+  const minimum = Math.min(requestedSize, minFontSize);
+  let size = requestedSize, result = layout(size);
+  while (result.overflow && size > minimum) {
+    size = Math.max(minimum, size - 1);
+    result = layout(size);
+  }
+  return result;
+}
+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 = record(item);
+    return `\u2022 ${flatten(item)}${entry.description ? `
+${flatten(entry.description)}` : ""}`;
+  }).join("\n");
+  if (field === "code") return flatten(record(value).source ?? value);
+  if (field === "quote") return flatten(record(value).text ?? value);
+  return void 0;
+}
+function tableOverflows(value, box, scale, settings, options) {
+  const table = record(value), rows2 = Array.isArray(table.rows) ? table.rows : [];
+  const allRows = Array.isArray(table.columns) && table.columns.length ? [table.columns, ...rows2] : rows2;
+  const columns2 = Math.max(1, ...allRows.map((row) => row.length));
+  const width = box.width / columns2 - 20 * scale;
+  const height = Math.min(54 * scale, box.height / Math.max(1, allRows.length)) - 12 * scale;
+  return width <= 0 || height <= 0 || allRows.some((row, index) => row.some((value2) => fitText(flatten(value2), { width, height }, 15 * scale, (settings.minFontSize ?? 16) * scale, textWidthMeasurer(resolveTextStyle({ fontFamily: options.fonts?.body ?? "sans-serif", fontWeight: index === 0 && table.columns?.length ? 700 : 400 }, options.textMeasurement), options.textMeasurement)).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 = record(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 = record(input), layout = record(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 composition = { ...record(layout.composition), ...record(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 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 fitContent = (field, value, text, box, size, minimum, path2) => field === "text" && Array.isArray(value) ? fitRichText(value, box, size, minimum, { style: styleFor(field, path2), textMeasurement: options.textMeasurement }) : 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 items = [], diagnostics = [];
+  let y = padding;
+  for (const field of ["tag", "title", "subtitle"]) {
+    if (!slide[field]) continue;
+    const requested = (field === "title" ? 54 : field === "tag" ? 16 : 25) * scale;
+    const maxHeight = height * (field === "title" ? 0.26 : field === "subtitle" ? 0.12 : 0.045);
+    const box = { x: padding, y, width: width - padding * 2, height: maxHeight };
+    const text = fitText(String(slide[field]), box, requested, minSize, widthFor(field, `${path}.${field}`));
+    box.height = Math.min(maxHeight, text.lines.length * text.lineHeight);
+    items.push({ path: `${path}.${field}`, field, type: "text", value: slide[field], payload: { text: slide[field] }, box, text, textStyle: styleFor(field, `${path}.${field}`), composition });
+    y += box.height + gap * 0.5;
+  }
+  if (items.length) y += gap * 0.5;
+  const contentBox = { x: padding, y, width: width - padding * 2, height: Math.max(scale, height - padding - 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 = record(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(record(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 regions = Object.keys(slide).filter((key) => regionParts(key)).sort();
+  const pending = regions.length ? regions.flatMap((key) => collect(record(slide[key]), `${path}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => collect(record(block), `${path}.blocks.${index}`)) : collect(slide, path);
+  const groups = [], flows = [];
+  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 leafScore = (node, box, settings) => {
+    const text = contentText(node.field, node.value);
+    let score = Math.abs(Math.log(box.width / box.height / 1.6));
+    if (text) {
+      const fit = fitContent(node.field, node.value, text, box, 25 * scale, (settings.minFontSize ?? 16) * scale, node.path);
+      score += (25 * scale - fit.fontSize) / scale + (fit.overflow ? 1e3 : 0);
+    }
+    if (node.field === "table" && tableOverflows(node.value, box, scale, settings, options)) score += 1e3;
+    if (box.width < 100 * scale || box.height < 60 * scale) score += 100;
+    return score;
+  };
+  const modeFor = (settings) => settings.mode ?? "auto";
+  const defaultColumns = (count, area, 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 * area.width / area.height / 1.6))));
+  };
+  const scoreNode = (node, box, settings) => {
+    if (!node.children) return leafScore(node, box, settings);
+    const own = inheritedSettings(settings, node.composition), area = inset(box, own);
+    const cols = defaultColumns(node.children.length, area, own);
+    const boxes = gridBoxes(node.children.length, area, 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), 0);
+  };
+  const arrange = (nodes, area, 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(area.width, area.height);
+    const actualGap = gapOverride ?? (settings === rootSettings ? gap : localGap);
+    let cols = defaultColumns(count, area, settings);
+    if (mode === "auto" && !nodes.some((node) => node.region)) {
+      let best = Infinity;
+      for (let candidate = 1; candidate <= Math.min(count, settings.columns ?? 6); candidate++) {
+        const boxes2 = gridBoxes(count, area, candidate, actualGap, settings.weights ?? [], false);
+        const score = nodes.reduce((sum, node, i) => sum + scoreNode(node, boxes2[i], settings), 0) + (Math.ceil(count / candidate) * candidate - count) * 2;
+        if (score < best) {
+          best = score;
+          cols = candidate;
+        }
+      }
+    }
+    const grid = gridGeometry(count, area, cols, actualGap, settings.weights ?? [], mode === "column");
+    const boxes = grid.boxes;
+    if (!nodes.some((node) => node.region)) flows.push({ path: containerPath, box: { ...area }, composition: { ...settings }, columns: grid.columns, rows: grid.rows, gap: grid.gap, itemCount: nodes.length, slotCount: count });
+    nodes.forEach((node, index) => {
+      const box = node.region ? regionBox(node.region, area, 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 textValue = contentText(node.field, node.value);
+        const text = 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, text, textStyle: styleFor(node.field, node.path), composition: settings });
+        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)) : [];
+  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)) 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.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) => strictPaths.has(diagnostic.path));
+  if (failures.length) throw new OPFCompositionError(failures);
+  return { width, height, contentBox, items, groups, flows, diagnostics, composition };
+}
+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 = record(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 { MAX_COMPOSITION_DEPTH, OPFCompositionError, composeSlide, fitList, fitRichText, fitText, measureText, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, textWidthMeasurer, wrapText };