@openpresentation/opf 0.11.3 → 0.12.0

package/dist/chunk-6TSDIPSH.js

@@ -0,0 +1,3624 @@
+import { catalogs } from './chunk-3ZGSWEHK.js';
+
+// 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/image-aspect.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function sourceOf(value) {
+  if (typeof value === "string") return value;
+  return isRecord(value) && typeof value.src === "string" ? value.src : void 0;
+}
+var PREFIX_BYTES = 64 * 1024;
+var JPEG_PREFIX_BYTES = 1024 * 1024;
+function dataBytes(uri, limit) {
+  const match = /^data:([^;,]*)((?:;[^;,]*)*),/i.exec(uri);
+  if (!match) return void 0;
+  const type = (match[1] ?? "").toLowerCase(), start = match[0].length;
+  try {
+    if (/;base64/i.test(match[2] ?? "")) {
+      const chars = Math.ceil(limit / 3) * 4, text2 = uri.slice(start, start + chars + chars / 8).replace(/\s+/g, "").slice(0, chars);
+      return { type, bytes: Uint8Array.from(atob(text2.slice(0, text2.length - text2.length % 4)), (char) => char.charCodeAt(0)) };
+    }
+    const prefix = uri.slice(start, start + limit).replace(/%[0-9a-f]?$/i, "");
+    return { type, bytes: new TextEncoder().encode(decodeURIComponent(prefix)) };
+  } catch {
+    return void 0;
+  }
+}
+var at = (b, i) => b[i] ?? 0;
+var u16be = (b, i) => at(b, i) << 8 | at(b, i + 1);
+var u32be = (b, i) => (at(b, i) << 24 | at(b, i + 1) << 16 | at(b, i + 2) << 8 | at(b, i + 3)) >>> 0;
+var u16le = (b, i) => at(b, i) | at(b, i + 1) << 8;
+var u24le = (b, i) => at(b, i) | at(b, i + 1) << 8 | at(b, i + 2) << 16;
+var ascii = (b, i, n) => String.fromCharCode(...b.subarray(i, i + n));
+function rasterDimensions(b) {
+  if (b.length >= 24 && u32be(b, 0) === 2303741511 && ascii(b, 12, 4) === "IHDR") return { width: u32be(b, 16), height: u32be(b, 20) };
+  if (b.length >= 10 && (ascii(b, 0, 6) === "GIF87a" || ascii(b, 0, 6) === "GIF89a")) return { width: u16le(b, 6), height: u16le(b, 8) };
+  if (b.length >= 4 && b[0] === 255 && b[1] === 216) {
+    let i = 2;
+    while (i + 9 < b.length) {
+      if (at(b, i) !== 255) {
+        i++;
+        continue;
+      }
+      const marker = at(b, i + 1);
+      if (marker === 255) {
+        i++;
+        continue;
+      }
+      if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+        i += 2;
+        continue;
+      }
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) return { height: u16be(b, i + 5), width: u16be(b, i + 7) };
+      i += 2 + u16be(b, i + 2);
+    }
+    return void 0;
+  }
+  if (b.length >= 30 && ascii(b, 0, 4) === "RIFF" && ascii(b, 8, 4) === "WEBP") {
+    const chunk = ascii(b, 12, 4);
+    if (chunk === "VP8X") return { width: u24le(b, 24) + 1, height: u24le(b, 27) + 1 };
+    if (chunk === "VP8L" && at(b, 20) === 47) {
+      const bits = u16le(b, 21) | u16le(b, 23) << 16;
+      return { width: (bits & 16383) + 1, height: (bits >>> 14 & 16383) + 1 };
+    }
+    if (chunk === "VP8 ") return { width: u16le(b, 26) & 16383, height: u16le(b, 28) & 16383 };
+  }
+  return void 0;
+}
+function svgDimensions(text2) {
+  const root = /<svg\b([^>]*)>/i.exec(text2)?.[1];
+  if (root === void 0) return void 0;
+  const attribute = (name) => new RegExp(`\\s${name}\\s*=\\s*["']([^"']*)["']`, "i").exec(root)?.[1];
+  const length = (value) => {
+    const match = value && /^\s*([0-9]*\.?[0-9]+)\s*(px|pt|in|cm|mm|em)?\s*$/i.exec(value);
+    return match ? Number(match[1]) : void 0;
+  };
+  const width = length(attribute("width")), height = length(attribute("height"));
+  if (width && height) return { width, height };
+  const box = attribute("viewBox")?.trim().split(/[\s,]+/).map(Number);
+  if (box && box.length === 4 && box.every(Number.isFinite)) {
+    const [, , width2 = 0, height2 = 0] = box;
+    if (width2 > 0 && height2 > 0) return { width: width2, height: height2 };
+  }
+  return void 0;
+}
+var cache = /* @__PURE__ */ new Map();
+var CACHE_ENTRIES = 64;
+function readDimensions(source) {
+  const first = dataBytes(source, PREFIX_BYTES);
+  if (!first) return void 0;
+  let dimensions;
+  if (first.type.startsWith("image/svg")) dimensions = svgDimensions(new TextDecoder().decode(first.bytes));
+  else {
+    dimensions = rasterDimensions(first.bytes);
+    if (!dimensions && first.bytes.length >= 2 && first.bytes[0] === 255 && first.bytes[1] === 216) {
+      const more = dataBytes(source, JPEG_PREFIX_BYTES);
+      if (more) dimensions = rasterDimensions(more.bytes);
+    }
+  }
+  return dimensions && dimensions.width > 0 && dimensions.height > 0 ? dimensions : void 0;
+}
+function intrinsicImageSize(value, assets) {
+  let source = sourceOf(value);
+  for (let hop = 0; source?.startsWith("asset:") && hop < 8; hop++) source = sourceOf(isRecord(assets) ? assets[source.slice(6)] : void 0);
+  if (!source?.startsWith("data:")) return void 0;
+  if (!cache.has(source)) {
+    if (cache.size >= CACHE_ENTRIES) cache.delete(cache.keys().next().value);
+    cache.set(source, readDimensions(source));
+  }
+  const size = cache.get(source);
+  return size ? { ...size, svg: /^data:image\/svg/i.test(source) } : void 0;
+}
+function intrinsicImageAspect(value, assets) {
+  const size = intrinsicImageSize(value, assets);
+  return size ? size.width / size.height : void 0;
+}
+
+// src/reading-order.ts
+function visualReadingOrder(items, direction = "ltr") {
+  const index = new Map(items.map((item, i) => [item, i]));
+  const along = direction === "rtl" ? (item) => -(item.box.x + item.box.width) : (item) => item.box.x;
+  return readingRows(items).flatMap((row) => [...row].sort((a, b) => along(a) - along(b) || a.box.y - b.box.y || index.get(a) - index.get(b)));
+}
+function readingRows(items) {
+  const index = new Map(items.map((item, i) => [item, i]));
+  const sorted = [...items].sort((a, b) => a.box.y - b.box.y || a.box.x - b.box.x || index.get(a) - index.get(b));
+  const rows2 = [];
+  for (const item of sorted) {
+    const centre = item.box.y + item.box.height / 2;
+    const row = rows2.find((candidate) => centre >= candidate.top && centre <= candidate.bottom);
+    if (row) {
+      row.items.push(item);
+      row.top = Math.min(row.top, item.box.y);
+      row.bottom = Math.max(row.bottom, item.box.y + item.box.height);
+    } else rows2.push({ top: item.box.y, bottom: item.box.y + item.box.height, items: [item] });
+  }
+  rows2.sort((a, b) => a.top - b.top);
+  return rows2.map((row) => row.items.sort((a, b) => index.get(a) - index.get(b)));
+}
+
+// src/direction.ts
+var strongRtl = /[\u200F\u061C]|(?=\p{L})[\p{Script=Arabic}\p{Script=Hebrew}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Nko}\p{Script=Adlam}\p{Script=Hanifi_Rohingya}\p{Script=Mandaic}\p{Script=Samaritan}\p{Script=Mende_Kikakui}\p{Script=Imperial_Aramaic}\p{Script=Phoenician}\p{Script=Kharoshthi}\p{Script=Old_South_Arabian}\p{Script=Old_North_Arabian}\p{Script=Avestan}\p{Script=Inscriptional_Parthian}\p{Script=Inscriptional_Pahlavi}\p{Script=Psalter_Pahlavi}\p{Script=Old_Turkic}\p{Script=Old_Hungarian}\p{Script=Nabataean}\p{Script=Palmyrene}\p{Script=Hatran}\p{Script=Manichaean}\p{Script=Sogdian}\p{Script=Old_Sogdian}\p{Script=Elymaic}\p{Script=Chorasmian}\p{Script=Yezidi}\p{Script=Cypriot}\p{Script=Lydian}\p{Script=Meroitic_Cursive}\p{Script=Meroitic_Hieroglyphs}\u{10F70}-\u{10FAF}\u{10D40}-\u{10D8F}]/u;
+var strongLtr = /[\u200E\p{L}\p{Nl}]/u;
+function paragraphDirection(text2, deckDirection) {
+  if (deckDirection !== "rtl") return "ltr";
+  let isolates = 0;
+  for (const char of String(text2 ?? "")) {
+    if (char === "\u2066" || char === "\u2067" || char === "\u2068") isolates += 1;
+    else if (char === "\u2069") isolates = Math.max(0, isolates - 1);
+    else if (isolates === 0) {
+      if (strongRtl.test(char)) return "rtl";
+      if (strongLtr.test(char)) return "ltr";
+    }
+  }
+  return "rtl";
+}
+function physicalAlignment(alignment, direction) {
+  const value = alignment ?? "left";
+  if (direction !== "rtl" || value === "center") return value;
+  return value === "left" ? "right" : "left";
+}
+function paragraphDirectionAt(text2, deckDirection) {
+  if (deckDirection !== "rtl") return () => "ltr";
+  const source = String(text2 ?? ""), starts = [], directions = [];
+  let start = 0;
+  const close = (end) => {
+    starts.push(start);
+    directions.push(paragraphDirection(source.slice(start, end), "rtl"));
+  };
+  for (const match of source.matchAll(/\r\n|\r|\n/g)) {
+    close(match.index);
+    start = match.index + match[0].length;
+  }
+  close(source.length);
+  return (offset) => {
+    for (let index = starts.length - 1; index >= 0; index--) if (offset >= starts[index]) return directions[index];
+    return directions[0];
+  };
+}
+
+// src/content-walk.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pathFor(parentPath, key) {
+  return parentPath === "/" ? `/${key}` : `${parentPath}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+}
+var bareIdPattern = /^[a-z0-9][a-z0-9-]*$/;
+var promotedRegionKeys = [
+  "left",
+  "center",
+  "right",
+  "left+center",
+  "center+right",
+  "left+center+right",
+  "top",
+  "middle",
+  "bottom",
+  "top+middle",
+  "middle+bottom",
+  "top+middle+bottom",
+  "top:left",
+  "top:center",
+  "top:right",
+  "top:left+center",
+  "top:center+right",
+  "top:left+center+right",
+  "middle:left",
+  "middle:center",
+  "middle:right",
+  "middle:left+center",
+  "middle:center+right",
+  "middle:left+center+right",
+  "bottom:left",
+  "bottom:center",
+  "bottom:right",
+  "bottom:left+center",
+  "bottom:center+right",
+  "bottom:left+center+right",
+  "top+middle:left",
+  "top+middle:center",
+  "top+middle:right",
+  "top+middle:left+center",
+  "top+middle:center+right",
+  "top+middle:left+center+right",
+  "middle+bottom:left",
+  "middle+bottom:center",
+  "middle+bottom:right",
+  "middle+bottom:left+center",
+  "middle+bottom:center+right",
+  "middle+bottom:left+center+right",
+  "top+middle+bottom:left",
+  "top+middle+bottom:center",
+  "top+middle+bottom:right",
+  "top+middle+bottom:left+center",
+  "top+middle+bottom:center+right",
+  "top+middle+bottom:left+center+right"
+];
+function visitContentPayloads(slide, slidePath, visit) {
+  const walk = (payload, path, depth, ancestors) => {
+    visit(payload, path);
+    if (!Array.isArray(payload.blocks) || depth >= MAX_COMPOSITION_DEPTH || ancestors.includes(payload)) return;
+    const nested = [...ancestors, payload];
+    const blocksPath = pathFor(path, "blocks");
+    payload.blocks.forEach((block, index) => {
+      if (isRecord2(block)) walk(block, `${blocksPath}/${index}`, depth + 1, nested);
+    });
+  };
+  if (Array.isArray(slide.blocks)) {
+    const blocksPath = pathFor(slidePath, "blocks");
+    slide.blocks.forEach((block, index) => {
+      if (isRecord2(block)) walk(block, `${blocksPath}/${index}`, 0, []);
+    });
+  }
+  for (const key of promotedRegionKeys) {
+    const region = slide[key];
+    if (isRecord2(region)) walk(region, pathFor(slidePath, key), 0, []);
+  }
+}
+
+// src/script-fonts.ts
+var eastAsianScripts = /* @__PURE__ */ new Set(["Hani", "Hans", "Hant", "Hanb", "Jpan", "Kore", "Hang", "Jamo", "Hira", "Kana", "Hrkt", "Bopo", "Yiii"]);
+var complexScripts = /* @__PURE__ */ new Set([
+  "Arab",
+  "Hebr",
+  "Syrc",
+  "Thaa",
+  "Nkoo",
+  "Adlm",
+  "Rohg",
+  "Mand",
+  "Samr",
+  "Deva",
+  "Beng",
+  "Guru",
+  "Gujr",
+  "Orya",
+  "Taml",
+  "Telu",
+  "Knda",
+  "Mlym",
+  "Sinh",
+  "Thai",
+  "Laoo",
+  "Tibt",
+  "Mymr",
+  "Khmr",
+  "Mong",
+  "Bali",
+  "Java",
+  "Lana",
+  "Tale",
+  "Talu",
+  "Cakm",
+  "Olck"
+]);
+var rtlScripts = /* @__PURE__ */ new Set(["Arab", "Hebr", "Syrc", "Thaa", "Nkoo", "Adlm", "Rohg", "Mand", "Samr"]);
+var latinSlotScripts = /* @__PURE__ */ new Set(["Latn", "Cyrl", "Grek", "Zyyy", "Zzzz"]);
+var deprecatedLanguages = { iw: "he", in: "id", ji: "yi" };
+var matchingLanguages = { ...deprecatedLanguages, no: "nb", zsm: "ms", ku: "kmr" };
+var likelyScripts = {
+  zh: { script: "Hans", regions: { TW: "Hant", HK: "Hant", MO: "Hant" } },
+  sr: { script: "Cyrl", regions: { ME: "Latn" } },
+  pa: { script: "Guru", regions: { PK: "Arab" } },
+  az: { script: "Latn", regions: { IR: "Arab" } },
+  uz: { script: "Latn", regions: { AF: "Arab" } },
+  bs: { script: "Latn" },
+  mn: { script: "Cyrl", regions: { CN: "Mong" } },
+  ms: { script: "Latn" }
+};
+var bareLanguageId = /^[a-z][a-z0-9-]*$/;
+function scriptFontRole(script) {
+  const code = normalizeScript(script);
+  if (code && eastAsianScripts.has(code)) return "eastAsian";
+  if (code && complexScripts.has(code)) return "complexScript";
+  return "latin";
+}
+function normalizeScript(value) {
+  if (typeof value !== "string" || !/^[A-Za-z]{4}$/.test(value)) return void 0;
+  return value.slice(0, 1).toUpperCase() + value.slice(1).toLowerCase();
+}
+function text(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+var tagSyntax = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/;
+function splitTag(tag) {
+  if (!tagSyntax.test(tag)) return void 0;
+  const [first = "", ...rest] = tag.split("-");
+  const language = first.toLowerCase();
+  if (language === "und") return void 0;
+  let script;
+  let region;
+  for (const subtag of rest) {
+    if (subtag.length === 1) break;
+    if (!script && !region && /^[A-Za-z]{4}$/.test(subtag)) script = normalizeScript(subtag);
+    else if (!region && /^(?:[A-Za-z]{2}|\d{3})$/.test(subtag)) region = subtag.toUpperCase();
+  }
+  return { language, script, region };
+}
+function canonicalTag(tag) {
+  let extension = false;
+  return tag.split("-").map((subtag, index) => {
+    const lower = subtag.toLowerCase();
+    if (index === 0) return deprecatedLanguages[lower] ?? lower;
+    if (extension) return lower;
+    if (subtag.length === 1) {
+      extension = true;
+      return lower;
+    }
+    if (/^[A-Za-z]{4}$/.test(subtag)) return normalizeScript(subtag);
+    if (/^[A-Za-z]{2}$/.test(subtag)) return subtag.toUpperCase();
+    return lower;
+  }).join("-");
+}
+function vendoredScript(language, region) {
+  const entry = likelyScripts[language];
+  return entry ? (region && entry.regions?.[region]) ?? entry.script : void 0;
+}
+function inferScript(tag) {
+  const parts = splitTag(tag);
+  if (!parts) return void 0;
+  const known = parts.script ?? vendoredScript(matchingLanguages[parts.language] ?? parts.language, parts.region);
+  if (known) return known;
+  try {
+    return normalizeScript(new Intl.Locale(tag).maximize().script);
+  } catch {
+    return void 0;
+  }
+}
+function inlineRecords(document, kind2) {
+  const kinds = isRecord2(document.catalogs) ? document.catalogs : {};
+  const entry = kinds[kind2];
+  return isRecord2(entry) && Array.isArray(entry.records) ? entry.records.filter(isRecord2) : [];
+}
+function allRecords(document, kind2) {
+  return [...inlineRecords(document, kind2), ...catalogs[kind2]];
+}
+function resolveReference(lookup, kind2, reference) {
+  if (typeof reference === "string") return lookup(kind2, reference);
+  if (!isRecord2(reference)) return void 0;
+  const base = typeof reference.id === "string" ? lookup(kind2, reference.id) : void 0;
+  return { ...base, ...reference };
+}
+function matchLanguageTag(document, tag) {
+  const wanted = splitTag(tag);
+  if (!wanted) return void 0;
+  const records = allRecords(document, "languages").filter((record5) => typeof record5.bcp47 === "string");
+  const key = canonicalTag(tag).toLowerCase();
+  const exact = records.find((record5) => canonicalTag(record5.bcp47).toLowerCase() === key);
+  if (exact) return exact;
+  const language = matchingLanguages[wanted.language] ?? wanted.language;
+  const script = wanted.script ?? vendoredScript(language, wanted.region);
+  const candidates = records.flatMap((record5) => {
+    const parts = splitTag(record5.bcp47);
+    if (!parts || (matchingLanguages[parts.language] ?? parts.language) !== language) return [];
+    const recordScript = normalizeScript(record5.script) ?? parts.script ?? vendoredScript(language, parts.region);
+    if (script && recordScript && script !== recordScript) return [];
+    return [{ record: record5, region: parts.region }];
+  });
+  return candidates.find((candidate) => wanted.region && candidate.region === wanted.region)?.record ?? candidates.find((candidate) => !candidate.region)?.record ?? candidates[0]?.record;
+}
+function resolveLanguage(document, lookup, reference) {
+  if (typeof reference === "string") {
+    const value = reference.trim();
+    const byId = bareLanguageId.test(value) ? lookup("languages", value) : void 0;
+    if (byId) return { record: byId, languageId: value };
+    if (/^[a-z][a-z0-9+.-]*:/i.test(value) || !splitTag(value)) return void 0;
+    const matched = matchLanguageTag(document, value);
+    if (matched) return { record: matched, authoredTag: value, languageId: text(matched.id) };
+    return inferScript(value) ? { record: {}, authoredTag: value } : void 0;
+  }
+  if (!isRecord2(reference)) return void 0;
+  const authoredTag = text(reference.bcp47);
+  if (authoredTag !== void 0 && !splitTag(authoredTag)) return void 0;
+  const base = typeof reference.id === "string" ? lookup("languages", reference.id) : authoredTag ? matchLanguageTag(document, authoredTag) : void 0;
+  const record5 = { ...base, ...reference };
+  const tag = text(record5.bcp47);
+  if (!tag || !splitTag(tag)) return void 0;
+  return { record: record5, authoredTag, authoredOoxmlLang: text(reference.ooxmlLang), languageId: text(base?.id) };
+}
+function pairFamilies(value) {
+  if (!isRecord2(value)) return void 0;
+  const major = text(value.major);
+  const minor = text(value.minor);
+  const heading = major ?? minor;
+  const body = minor ?? major;
+  return heading && body ? { heading, body } : void 0;
+}
+function schemeServesLanguage(scheme, language) {
+  const entries = Array.isArray(scheme.languages) ? scheme.languages.filter((entry) => typeof entry === "string") : [];
+  if (entries.length === 0) return true;
+  const name = text(language.name)?.toLowerCase();
+  if (!name) return false;
+  const base = name.replace(/\s*\([^)]*\)\s*$/, "");
+  return entries.some((entry) => {
+    const value = entry.trim().toLowerCase();
+    return value === name || value === base;
+  });
+}
+function resolveScriptFonts(input, options = {}) {
+  const document = isRecord2(input) ? input : {};
+  const lookup = (kind2, id) => inlineRecords(document, kind2).find((record6) => record6.id === id) ?? catalogs[kind2].find((record6) => record6.id === id);
+  let design = isRecord2(document.design) ? document.design : {};
+  if (options.slideIndex !== void 0) {
+    const slides = Array.isArray(document.slides) ? document.slides : [];
+    if (!Number.isInteger(options.slideIndex) || options.slideIndex < 0 || options.slideIndex >= slides.length) {
+      throw new RangeError(`slideIndex must be an integer between 0 and ${slides.length - 1}.`);
+    }
+    const slide = slides[options.slideIndex];
+    if (isRecord2(slide) && isRecord2(slide.design)) design = { ...design, ...slide.design };
+  }
+  const theme = resolveReference(lookup, "themes", design.theme ?? "minimal") ?? {};
+  const scheme = resolveFontSchemeReference(design.fontScheme ?? theme.fontScheme ?? DEFAULT_FONT_SCHEME, (id) => lookup("fontSchemes", id)).scheme;
+  const latin = resolveFontFamilies(scheme);
+  const fromOption = options.language !== void 0 ? resolveLanguage(document, lookup, options.language) : void 0;
+  const fromDocument = fromOption ? void 0 : resolveLanguage(document, lookup, document.language);
+  const requestedDefault = text(options.defaultLanguage);
+  const fallbackTag = requestedDefault && splitTag(requestedDefault) ? requestedDefault : "en-US";
+  const language = fromOption ?? fromDocument ?? resolveLanguage(document, lookup, fallbackTag) ?? { record: {}, authoredTag: fallbackTag };
+  const languageSource = fromOption ? "option" : fromDocument ? "document" : "default";
+  const record5 = language.record;
+  const bcp47 = canonicalTag(language.authoredTag ?? text(record5.bcp47) ?? fallbackTag);
+  const curated = text(record5.ooxmlLang);
+  const lang = language.authoredOoxmlLang ? canonicalTag(language.authoredOoxmlLang) : language.authoredTag && splitTag(language.authoredTag)?.region ? canonicalTag(language.authoredTag) : curated ? canonicalTag(curated) : bcp47;
+  const parts = splitTag(bcp47);
+  const script = normalizeScript(record5.script) ?? (language.languageId ? parts?.script ?? (parts ? vendoredScript(matchingLanguages[parts.language] ?? parts.language, parts.region) : void 0) ?? normalizeScript(matchLanguageTag({}, bcp47)?.script) : inferScript(bcp47)) ?? "Zzzz";
+  const scriptRole = scriptFontRole(script);
+  const declaredDirection = record5.direction;
+  const direction = declaredDirection === "rtl" || declaredDirection === "ltr" ? declaredDirection : rtlScripts.has(script) ? "rtl" : "ltr";
+  const app = options.app ?? "PowerPoint";
+  const preferred = app === "Google Slides" ? record5.googleFontScheme : record5.fontScheme;
+  const alternate = app === "Google Slides" ? record5.fontScheme : record5.googleFontScheme;
+  const languageScheme = resolveReference(lookup, "fontSchemes", preferred) ?? resolveReference(lookup, "fontSchemes", alternate);
+  const languageFamilies = pairFamilies(languageScheme);
+  const schemeAdmitsLanguage = schemeServesLanguage(scheme, record5);
+  const slot = (role, family) => {
+    const explicit = pairFamilies(scheme[role]);
+    if (explicit) return { ...explicit, source: "fontScheme" };
+    if (scheme.languageFamily === family && schemeAdmitsLanguage) return { ...latin, source: "schemeFamily" };
+    if (scriptRole === role && languageFamilies) return { ...languageFamilies, source: "language" };
+    return { heading: latin.heading, body: latin.body, source: "latin" };
+  };
+  const eastAsian = slot("eastAsian", "ea");
+  const complexScript = slot("complexScript", "cs");
+  const heading = { latin: latin.heading, eastAsian: eastAsian.heading, complexScript: complexScript.heading };
+  const body = { latin: latin.body, eastAsian: eastAsian.body, complexScript: complexScript.body };
+  let supplement;
+  if (!latinSlotScripts.has(script)) {
+    const families = scriptRole === "latin" ? languageFamilies : (scriptRole === "eastAsian" ? eastAsian : complexScript).source === "latin" ? void 0 : { heading: heading[scriptRole], body: body[scriptRole] };
+    if (families) supplement = { script: script === "Kore" ? "Hang" : script, heading: families.heading, body: families.body };
+  }
+  return {
+    ...body,
+    lang,
+    bcp47,
+    ...language.languageId ? { languageId: language.languageId } : {},
+    languageSource,
+    script,
+    scriptRole,
+    direction,
+    rtl: direction === "rtl",
+    heading,
+    body,
+    ...supplement ? { supplement } : {},
+    sources: { eastAsian: eastAsian.source, complexScript: complexScript.source }
+  };
+}
+function resolveSlideDirection(presentation, slideIndex) {
+  if (!isRecord2(presentation) || presentation.language === void 0) return "ltr";
+  try {
+    return resolveScriptFonts(presentation, Number.isInteger(slideIndex) ? { slideIndex } : {}).direction;
+  } catch {
+    try {
+      return resolveScriptFonts(presentation).direction;
+    } catch {
+      return "ltr";
+    }
+  }
+}
+
+// src/numbering.ts
+var NUMBERING_STYLES = ["arabic", "roman-upper", "roman-lower", "alpha-upper", "alpha-lower"];
+var NUMBERING_SUFFIXES = ["period", "paren", "paren-both"];
+var MAX_NUMBERING_VALUE = 32767;
+var MAX_ROMAN_VALUE = 3999;
+var MAX_NUMBERING_LEVELS = 9;
+var styleSet = new Set(NUMBERING_STYLES);
+var suffixSet = new Set(NUMBERING_SUFFIXES);
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function resolveEntry(entry, label) {
+  if (typeof entry === "string") {
+    if (!styleSet.has(entry)) throw new RangeError(`${label} must be one of ${NUMBERING_STYLES.join(", ")}.`);
+    return { style: entry, start: 1, suffix: "period" };
+  }
+  if (!isObject(entry)) throw new TypeError(`${label} must be a style name or a numbering object.`);
+  const { style = "arabic", start = 1, suffix = "period" } = entry;
+  if (typeof style !== "string" || !styleSet.has(style)) throw new RangeError(`${label}.style must be one of ${NUMBERING_STYLES.join(", ")}.`);
+  if (typeof suffix !== "string" || !suffixSet.has(suffix)) throw new RangeError(`${label}.suffix must be one of ${NUMBERING_SUFFIXES.join(", ")}.`);
+  if (typeof start !== "number" || !Number.isInteger(start) || start < 1 || start > MAX_NUMBERING_VALUE) throw new RangeError(`${label}.start must be an integer from 1 to ${MAX_NUMBERING_VALUE}.`);
+  return { style, start, suffix };
+}
+function resolveNumbering(input) {
+  if (Array.isArray(input)) {
+    if (!input.length || input.length > MAX_NUMBERING_LEVELS) throw new RangeError(`numbering must list from 1 to ${MAX_NUMBERING_LEVELS} levels.`);
+    return input.map((entry, index) => resolveEntry(entry, `numbering[${index}]`));
+  }
+  return [resolveEntry(input, "numbering")];
+}
+function numberingAtLevel(levels, level) {
+  return levels[Math.min(Math.max(0, level), levels.length - 1)];
+}
+var ROMAN = [[1e3, "m"], [900, "cm"], [500, "d"], [400, "cd"], [100, "c"], [90, "xc"], [50, "l"], [40, "xl"], [10, "x"], [9, "ix"], [5, "v"], [4, "iv"], [1, "i"]];
+function bareNumber(value, style) {
+  if (style === "arabic") return String(value);
+  if (style === "roman-upper" || style === "roman-lower") {
+    if (value > MAX_ROMAN_VALUE) return null;
+    let rest = value, out = "";
+    for (const [amount, glyphs] of ROMAN) while (rest >= amount) {
+      out += glyphs;
+      rest -= amount;
+    }
+    return style === "roman-upper" ? out.toUpperCase() : out;
+  }
+  const letter = String.fromCharCode(97 + (value - 1) % 26).repeat(Math.floor((value - 1) / 26) + 1);
+  return style === "alpha-upper" ? letter.toUpperCase() : letter;
+}
+function numberingStyleDraws(style, value) {
+  return bareNumber(value, style) !== null;
+}
+function formatListNumber(value, style = "arabic", suffix = "period") {
+  if (!Number.isInteger(value) || value < 1) throw new RangeError("A list number must be an integer of at least 1.");
+  if (!styleSet.has(style)) throw new RangeError(`Unknown numbering style '${String(style)}'.`);
+  if (!suffixSet.has(suffix)) throw new RangeError(`Unknown numbering suffix '${String(suffix)}'.`);
+  const bare = bareNumber(value, style) ?? String(value);
+  return suffix === "period" ? `${bare}.` : suffix === "paren" ? `${bare})` : `(${bare})`;
+}
+function listNumbers(items, numbering) {
+  const levels = resolveNumbering(numbering);
+  const counters = [];
+  return items.map((item, index) => {
+    const object = isObject(item) ? item : void 0;
+    const level = object?.level === void 0 ? 0 : object.level;
+    if (typeof level !== "number" || !Number.isInteger(level) || level < 0) throw new RangeError("List levels must be nonnegative integers.");
+    const own = object?.start;
+    if (own !== void 0 && (typeof own !== "number" || !Number.isInteger(own) || own < 1 || own > MAX_NUMBERING_VALUE)) throw new RangeError(`A list item start must be an integer from 1 to ${MAX_NUMBERING_VALUE}.`);
+    const { style: authored, start, suffix } = numberingAtLevel(levels, level);
+    const previous = counters[level];
+    const value = own ?? (previous === void 0 ? start : previous + 1);
+    counters[level] = value;
+    counters.length = level + 1;
+    const adapted = !numberingStyleDraws(authored, value);
+    const style = adapted ? "arabic" : authored;
+    return { index, level, value, style, suffix, text: formatListNumber(value, style, suffix), ...adapted ? { adapted: "roman-range" } : {} };
+  });
+}
+function sliceNumberedItems(items, numbering, from, to = items.length) {
+  const whole = listNumbers(items, numbering);
+  const result = items.slice(from, to);
+  for (let index = 0; index < result.length; index++) {
+    const wanted = whole[from + index].value;
+    if (listNumbers(result.slice(0, index + 1), numbering)[index].value === wanted) continue;
+    const item = result[index];
+    const object = isObject(item) ? item : { text: item };
+    result[index] = { ...object, start: wanted };
+  }
+  return result;
+}
+function numberingFindings(payload) {
+  const errors = [], warnings = [];
+  const lists = ["items", "bullets"].filter((key) => Array.isArray(payload[key]));
+  if (Object.hasOwn(payload, "numbering")) {
+    if (!Object.hasOwn(payload, "items") && !Object.hasOwn(payload, "bullets")) {
+      errors.push({ key: "numbering", message: "numbering applies to 'items' or 'bullets'; this payload has neither", params: {} });
+    } else {
+      for (const key of lists) {
+        let numbers;
+        try {
+          numbers = listNumbers(payload[key], payload.numbering);
+        } catch {
+          continue;
+        }
+        const largest = numbers.reduce((max, number) => Math.max(max, number.value), 0);
+        if (largest > MAX_NUMBERING_VALUE) errors.push({ key, message: `numbering counts up to ${largest}, past the native limit of ${MAX_NUMBERING_VALUE}`, params: { largest, limit: MAX_NUMBERING_VALUE } });
+      }
+    }
+  } else {
+    for (const key of lists) {
+      if (payload[key].some((item) => isObject(item) && item.start !== void 0)) {
+        warnings.push({ key, message: `'start' on ${key} entries has no effect without a 'numbering' field on the payload`, params: {} });
+      }
+    }
+  }
+  return { errors, warnings };
+}
+
+// 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 = (text2) => {
+    const last = tokens[tokens.length - 1];
+    if (last?.kind === "literal") last.text += text2;
+    else tokens.push({ kind: "literal", text: text2 });
+  };
+  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, text2 = "";
+      for (; ; ) {
+        if (end >= pattern.length) return "dateFormat has an unterminated quoted literal.";
+        if (pattern[end] === "'") {
+          if (pattern[end + 1] === "'") {
+            text2 += "'";
+            end += 2;
+            continue;
+          }
+          break;
+        }
+        text2 += pattern[end];
+        end++;
+      }
+      literal(text2);
+      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 text2 = "";
+  for (const token of tokens) {
+    if (token.kind === "literal") {
+      text2 += token.text;
+      continue;
+    }
+    const { letter, width } = token;
+    if (letter === "y") text2 += 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] ?? "";
+      text2 += width >= 3 ? width === 4 ? name : name.slice(0, 3) : pad(date.month, width);
+    } else if (letter === "d") text2 += pad(date.day, width);
+    else {
+      const name = weekdays[utc.getUTCDay()] ?? "";
+      text2 += width === 4 ? name : name.slice(0, 3);
+    }
+  }
+  return { text: text2 };
+}
+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 text2 = "";
+  const fields2 = [];
+  for (const piece of format.split(/(\{current\}|\{total\})/)) {
+    if (piece === "{current}") {
+      const value = String(current);
+      fields2.push({ type: "slideNumber", start: text2.length, end: text2.length + value.length });
+      text2 += value;
+    } else if (piece === "{total}") text2 += String(total);
+    else text2 += piece;
+  }
+  return { text: text2, 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);
+}
+var CHART_SERIES_MIN_LIGHTNESS_STEP = 11;
+var CHART_SERIES_MIN_DIFFERENCE = 12;
+var D65 = [0.95047, 1, 1.08883];
+function opaqueChannels(value) {
+  if (luminance(value) === void 0) return void 0;
+  let hex = value.trim();
+  if (hex.length === 4) hex = `#${[...hex.slice(1)].map((c) => c + c).join("")}`;
+  return [1, 3, 5].map((offset) => Number.parseInt(hex.slice(offset, offset + 2), 16));
+}
+var toLinear = (channel) => {
+  const n = channel / 255;
+  return n <= 0.04045 ? n / 12.92 : ((n + 0.055) / 1.055) ** 2.4;
+};
+var fromLinear = (value) => 255 * (value <= 31308e-7 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055);
+function labOf(channels) {
+  const [r, g, b] = channels.map(toLinear);
+  const f = (t) => t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
+  const fx = f((0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / D65[0]), fy = f(0.2126729 * r + 0.7151522 * g + 0.072175 * b), fz = f((0.0193339 * r + 0.119192 * g + 0.9503041 * b) / D65[2]);
+  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
+}
+function labToLinear([l, a, b]) {
+  const fy = (l + 16) / 116, fx = fy + a / 500, fz = fy - b / 200;
+  const inverse = (t) => t ** 3 > 216 / 24389 ? t ** 3 : (116 * t - 16) / (24389 / 27);
+  const x = inverse(fx) * D65[0], y = l > 8 ? fy ** 3 : l / (24389 / 27), z = inverse(fz) * D65[2];
+  const rgb = [
+    3.2404542 * x - 1.5371385 * y - 0.4985314 * z,
+    -0.969266 * x + 1.8760108 * y + 0.041556 * z,
+    0.0556434 * x - 0.2040259 * y + 1.0572252 * z
+  ];
+  return rgb.every((channel) => channel >= -5e-4 && channel <= 1.0005) ? rgb : void 0;
+}
+var hexOfChannels = (channels) => `#${channels.map((channel) => Math.max(0, Math.min(255, Math.round(channel))).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
+function labWithLightness(l, a, b) {
+  const chroma = Math.hypot(a, b), hue = Math.atan2(b, a);
+  const at2 = (scale) => labToLinear([l, Math.cos(hue) * chroma * scale, Math.sin(hue) * chroma * scale]);
+  let linear = at2(1);
+  if (!linear) {
+    let low = 0, high = 1;
+    for (let step = 0; step < 24; step++) {
+      const mid = (low + high) / 2;
+      if (at2(mid)) low = mid;
+      else high = mid;
+    }
+    linear = at2(low) ?? [0, 0, 0];
+  }
+  return hexOfChannels(linear.map((channel) => fromLinear(Math.max(0, Math.min(1, channel)))));
+}
+function labDifference(a, b) {
+  return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+}
+var CHART_SERIES_SHORTFALL_WEIGHT = 8;
+function chartPaletteForFill(fill, palette) {
+  const opaqueFill = colorContrast(fill, fill) !== void 0;
+  const preferredLab = palette.map((color) => {
+    const channels = opaqueChannels(color);
+    return channels ? labOf(channels) : void 0;
+  });
+  const adjusted = palette.map((color) => chartColorForFill(fill, color));
+  const kept = palette.map((color, index) => opaqueFill && preferredLab[index] !== void 0 && adjusted[index] === color);
+  const placed = palette.map((_, index) => kept[index] || !opaqueFill || !preferredLab[index] ? adjusted[index] : void 0);
+  const placedLab = placed.map((color) => {
+    const channels = color === void 0 ? void 0 : opaqueChannels(color);
+    return channels ? labOf(channels) : void 0;
+  });
+  palette.forEach((_, index) => {
+    const wanted = preferredLab[index], base = adjusted[index];
+    if (placed[index] !== void 0 || !wanted) return;
+    const baseLab = labOf(opaqueChannels(base));
+    const needs = palette.flatMap((_2, other) => {
+      const before = preferredLab[other], lab = placedLab[other];
+      return other !== index && before && lab && placed[other] !== void 0 ? [{ lab, adjacent: Math.abs(other - index) === 1, wide: Math.min(labDifference(before, wanted), CHART_SERIES_MIN_DIFFERENCE), step: Math.min(Math.abs(before[0] - wanted[0]), CHART_SERIES_MIN_LIGHTNESS_STEP) }] : [];
+    });
+    const shortfall = (candidate) => needs.reduce((worst, need) => {
+      const lightness = Math.abs(need.lab[0] - candidate[0]) - need.step, difference = labDifference(need.lab, candidate) - need.wide;
+      return need.adjacent ? { near: Math.min(worst.near, difference, lightness), far: worst.far } : { near: Math.min(worst.near, difference), far: Math.min(worst.far, lightness) };
+    }, { near: Infinity, far: Infinity });
+    const deficit = (value) => Math.max(0, -value - 1e-9);
+    const cost = (candidate) => candidate.moved + CHART_SERIES_SHORTFALL_WEIGHT * deficit(candidate.near) + deficit(candidate.far);
+    const start = shortfall(baseLab);
+    if (deficit(start.near) === 0 && deficit(start.far) === 0) {
+      placed[index] = base;
+      placedLab[index] = baseLab;
+      return;
+    }
+    let best = { color: base, lab: baseLab, cost: cost({ moved: 0, ...start }), moved: 0 };
+    for (let step = 0; step <= 400; step++) {
+      const color = labWithLightness(step / 4, wanted[1], wanted[2]), contrast = colorContrast(color, fill);
+      if (contrast === void 0 || contrast < 3) continue;
+      const lab = labOf(opaqueChannels(color)), moved = Math.abs(lab[0] - baseLab[0]), total = cost({ moved, ...shortfall(lab) });
+      if (total < best.cost - 1e-9 || Math.abs(total - best.cost) <= 1e-9 && moved < best.moved) best = { color, lab, cost: total, moved };
+    }
+    placed[index] = best.color;
+    placedLab[index] = best.lab;
+  });
+  return placed;
+}
+
+// src/annotations.ts
+var CITATION_MARKER_SCALE = 2 / 3;
+var CITATION_MARKER_RAISE = 0.3;
+var CAPTION_FONT_RATIO = 0.6;
+var CAPTION_MAX_RATIO = 0.35;
+var FOOTNOTE_MAX_RATIO = 0.35;
+var CAPTIONABLE_FIELDS = Object.freeze(["image", "chart", "table", "video"]);
+var record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var isRecord3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var round = (value) => Math.round(value * 1e6) / 1e6 || value;
+var regionKey = /^(top|middle|bottom|left|center|right)([+:]|$)/;
+var TEXT_FIELDS = ["text", "items", "bullets"];
+function annotationText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map((run) => typeof run === "string" ? run : record2(run).text ?? "").join("");
+  if (isRecord3(value) && value.text !== void 0) return annotationText(value.text);
+  return value === void 0 || value === null ? "" : String(value);
+}
+function captionSettings(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string" || Array.isArray(value)) return { text: value, position: "below", align: "left" };
+  if (!isRecord3(value) || value.text === void 0) return void 0;
+  return { text: value.text, position: value.position === "above" ? "above" : "below", align: value.align === "center" || value.align === "right" ? value.align : "left" };
+}
+function walkCitationRuns(slide, basePath, visit) {
+  const runs = (value2, path) => {
+    if (!Array.isArray(value2)) return;
+    value2.forEach((run, index) => {
+      if (!isRecord3(run) || typeof run.text !== "string") return;
+      const cite = run.cite === void 0 ? [] : Array.isArray(run.cite) ? run.cite.filter((id) => typeof id === "string") : typeof run.cite === "string" ? [run.cite] : [];
+      const footnote = typeof run.footnote === "string" || Array.isArray(run.footnote) ? run.footnote : void 0;
+      if (!cite.length && footnote === void 0) return;
+      visit({ path: `${path}.${index}`, run, cite, footnote });
+    });
+  };
+  const list = (items, path) => {
+    if (!Array.isArray(items)) return;
+    items.forEach((item, index) => {
+      if (Array.isArray(item)) runs(item, `${path}.${index}`);
+      else if (isRecord3(item)) {
+        runs(item.text, `${path}.${index}.text`);
+        runs(item.description, `${path}.${index}.description`);
+      }
+    });
+  };
+  const host = (node, path, depth) => {
+    const payload = record2(node);
+    if (Array.isArray(payload.blocks)) {
+      if (depth > 32) return;
+      payload.blocks.forEach((block, index) => {
+        host(block, `${path}.blocks.${index}`, depth + 1);
+      });
+      return;
+    }
+    for (const field of TEXT_FIELDS) {
+      if (payload[field] === void 0) continue;
+      if (field === "text") runs(payload.text, `${path}.text`);
+      else list(payload[field], `${path}.${field}`);
+    }
+  };
+  const value = record2(slide);
+  const regions = Object.keys(value).filter((key) => regionKey.test(key)).sort();
+  if (regions.length) {
+    for (const key of regions) host(value[key], `${basePath}.${key}`, 0);
+    return;
+  }
+  if (Array.isArray(value.blocks)) {
+    value.blocks.forEach((block, index) => {
+      host(block, `${basePath}.blocks.${index}`, 0);
+    });
+    return;
+  }
+  host(value, basePath, 0);
+}
+var citationMarkerText = (numbers) => numbers.join(",");
+function referenceList(presentation) {
+  const list = record2(presentation).references;
+  return Array.isArray(list) ? list.filter((item) => isRecord3(item) && typeof item.id === "string") : [];
+}
+function numberSlide(slide, slideIndex, references, numbering) {
+  const markers = /* @__PURE__ */ new Map(), marked = [], used = /* @__PURE__ */ new Map();
+  walkCitationRuns(slide, `slides.${slideIndex}`, (entry) => {
+    const numbers = [];
+    for (const id of entry.cite) {
+      let note = numbering.byId.get(id);
+      if (!note) {
+        const index = references.findIndex((item) => item.id === id), reference = references[index];
+        note = { number: numbering.notes.length + 1, kind: "reference", id, text: reference?.text ?? id, sourcePath: index >= 0 ? `references.${index}` : entry.path, resolved: !!reference, ...typeof reference?.url === "string" ? { url: reference.url } : {} };
+        numbering.notes.push(note);
+        numbering.byId.set(id, note);
+      }
+      if (!numbers.includes(note.number)) numbers.push(note.number);
+      used.set(note.number, note);
+    }
+    if (entry.footnote !== void 0) {
+      const note = { number: numbering.notes.length + 1, kind: "footnote", text: entry.footnote, sourcePath: entry.path, resolved: true };
+      numbering.notes.push(note);
+      numbers.push(note.number);
+      used.set(note.number, note);
+    }
+    const text2 = citationMarkerText(numbers);
+    markers.set(entry.path, text2);
+    marked.push({ path: entry.path, numbers, text: text2 });
+  });
+  if (!marked.length) return void 0;
+  return { markers, marked, notes: [...used.values()].sort((a, b) => a.number - b.number) };
+}
+function collectCitations(presentation) {
+  const references = referenceList(presentation), numbering = { notes: [], byId: /* @__PURE__ */ new Map() }, slides = /* @__PURE__ */ new Map();
+  const list = record2(presentation).slides;
+  if (Array.isArray(list)) list.forEach((slide, index) => {
+    const result = numberSlide(slide, index, references, numbering);
+    if (result) slides.set(index, result);
+  });
+  const cited = new Set(numbering.notes.filter((note) => note.kind === "reference").map((note) => note.id));
+  return { notes: numbering.notes, references: numbering.notes.filter((note) => note.kind === "reference"), slides, unused: references.map((item) => item.id).filter((id) => !cited.has(id)) };
+}
+function slideCitations(slide, slideIndex, presentation) {
+  const references = referenceList(presentation), numbering = { notes: [], byId: /* @__PURE__ */ new Map() };
+  const list = record2(presentation).slides;
+  if (Array.isArray(list)) for (let index = 0; index < Math.min(slideIndex, list.length); index += 1) numberSlide(list[index], index, references, numbering);
+  return numberSlide(slide, slideIndex, references, numbering);
+}
+var fitHeight = (fit) => Math.max(fit.placement?.height ?? 0, "richLines" in fit ? fit.height : fit.lines.length * fit.lineHeight);
+function layoutCaption(value, box, path, options) {
+  const settings = captionSettings(value);
+  if (!settings) return void 0;
+  const fontSize = Math.max(options.minFontSize, CAPTION_FONT_RATIO * 25 * options.scale), gap = fontSize * 0.4;
+  const maxHeight = Math.max(fontSize * 1.22, box.height * CAPTION_MAX_RATIO);
+  const diagnostics = [];
+  const probe = options.fit(settings.text, { x: box.x, y: box.y, width: box.width, height: maxHeight }, fontSize, fontSize, path, settings.align);
+  const height = Math.min(maxHeight, Math.max(fontSize * 1.22, fitHeight(probe)));
+  const captionBox = { x: box.x, y: settings.position === "above" ? box.y : box.y + box.height - height, width: box.width, height };
+  const fit = options.fit(settings.text, captionBox, fontSize, fontSize, path, settings.align);
+  const overflow = fit.overflow || fitHeight(fit) > height + 0.01;
+  if (overflow) diagnostics.push({ code: "text-overflow", path, message: "The caption does not fit its band at the minimum font size; shorten it or give the block more space." });
+  const mediaHeight = Math.max(options.scale, box.height - height - gap);
+  const mediaBox = { x: box.x, y: settings.position === "above" ? box.y + height + gap : box.y, width: box.width, height: mediaHeight };
+  for (const target of [captionBox, mediaBox]) for (const key of ["x", "y", "width", "height"]) target[key] = round(target[key]);
+  return { path, value, text: settings.text, position: settings.position, alignment: settings.align, box: captionBox, mediaBox, fit, textStyle: options.textStyle(path), fontSize, overflow, diagnostics };
+}
+function layoutFootnotes(citations, options) {
+  const fontSize = Math.max(options.minFontSize, 13 * options.scale), thickness = Math.max(1, round(options.scale));
+  const gap = fontSize * 0.5, spacing = fontSize * 0.25, diagnostics = [];
+  const width = Math.max(options.scale, options.width);
+  const measured = citations.notes.map((note) => {
+    const value = typeof note.text === "string" ? `${note.number} ${note.text}` : [`${note.number} `, ...note.text];
+    const probe = options.fit(value, { x: options.x, y: 0, width, height: Number.MAX_SAFE_INTEGER }, fontSize, fontSize, note.sourcePath, "left");
+    return { note, value, height: Math.max(fontSize * 1.22, fitHeight(probe)) };
+  });
+  const total = thickness + gap + measured.reduce((sum, item) => sum + item.height, 0) + spacing * Math.max(0, measured.length - 1);
+  const height = round(Math.min(total, Math.max(fontSize * 1.22 + thickness + gap, options.maxHeight)));
+  const top = round(options.bottom - height), box = { x: round(options.x), y: top, width: round(width), height };
+  let cursor = top + thickness + gap, overflow = false;
+  const entries = measured.map((item, index) => {
+    const entryBox = { x: box.x, y: round(cursor), width: box.width, height: round(item.height) };
+    const fit = options.fit(item.value, entryBox, fontSize, fontSize, item.note.sourcePath, "left");
+    const exceeds = fit.overflow || entryBox.y + entryBox.height > options.bottom + 0.01;
+    if (exceeds) {
+      overflow = true;
+      diagnostics.push({ code: "text-overflow", path: item.note.sourcePath, message: `Footnote ${item.note.number} does not fit the slide's footnote area; shorten the note or split the slide.` });
+    }
+    cursor += item.height + (index < measured.length - 1 ? spacing : 0);
+    return { number: item.note.number, kind: item.note.kind, ...item.note.id !== void 0 ? { id: item.note.id } : {}, sourcePath: item.note.sourcePath, value: item.value, text: item.note.text, box: entryBox, fit, textStyle: options.textStyle(item.note.sourcePath), ...item.note.url !== void 0 ? { url: item.note.url } : {}, overflow: exceeds };
+  });
+  for (const note of citations.notes) if (!note.resolved) diagnostics.push({ code: "unresolved-content", path: note.sourcePath, message: `Reference '${note.id}' is not in the presentation's references list; its id is listed instead.` });
+  return { algorithm: "footnote-area-v1", path: options.path, box, rule: { x: box.x, y: top, width: box.width, thickness }, entries, markers: citations.marked, fontSize, overflow, diagnostics };
+}
+function referencesSlide(presentation, options = {}) {
+  const title = options.title ?? "References";
+  const { references } = collectCitations(presentation);
+  if (!references.length) return { title };
+  const items = references.map((note) => {
+    const label = `${note.number}. `;
+    if (typeof note.text === "string" && note.url === void 0) return `${label}${note.text}`;
+    const runs = [label, ...typeof note.text === "string" ? [note.text] : note.text];
+    if (note.url !== void 0) runs.push(" ", { text: note.url, link: note.url });
+    return runs;
+  });
+  return { title, items };
+}
+
+// src/generated/catalog-ids.ts
+var catalogIds = {
+  audiences: [
+    "executives",
+    "board",
+    "engineering-team",
+    "investors",
+    "customers",
+    "sales-team",
+    "marketing-team",
+    "all-hands",
+    "candidates",
+    "regulators",
+    "executive",
+    "investor",
+    "technical",
+    "sales",
+    "marketing",
+    "academic",
+    "internal-team",
+    "customer",
+    "general-public",
+    "media",
+    "partner",
+    "regulatory"
+  ],
+  purposes: [
+    "inform",
+    "decide",
+    "align",
+    "persuade",
+    "educate",
+    "report",
+    "pitch",
+    "sell",
+    "plan"
+  ],
+  tones: [
+    "formal",
+    "casual",
+    "inspirational",
+    "technical",
+    "persuasive",
+    "authoritative",
+    "conversational"
+  ],
+  themes: [
+    "minimal",
+    "classic",
+    "dark",
+    "bold"
+  ],
+  layouts: [
+    "blank",
+    "chart-1x",
+    "chart-2x",
+    "chart-3x",
+    "code-1x",
+    "image-1x",
+    "image-2x",
+    "image-3x",
+    "image-bleed",
+    "list-1x",
+    "list-2x",
+    "list-3x",
+    "list-4x",
+    "list-5x",
+    "list-6x",
+    "media-1x",
+    "number-1x",
+    "number-2x",
+    "number-3x",
+    "number-4x",
+    "number-5x",
+    "number-6x",
+    "quote-1x",
+    "table-1x",
+    "text-1x",
+    "text-2x",
+    "text-3x",
+    "timeline-1x",
+    "title",
+    "title-subtitle",
+    "title-slide",
+    "two-column",
+    "image-focus",
+    "data-visualization",
+    "quote-highlight",
+    "section-divider",
+    "agenda",
+    "thank-you-cta",
+    "bullet-list",
+    "three-column",
+    "icon-grid",
+    "faq",
+    "stats-metrics",
+    "comparison",
+    "swot-analysis",
+    "matrix-quadrant",
+    "funnel-pyramid",
+    "timeline",
+    "process-flow",
+    "photo-grid",
+    "before-after",
+    "testimonial-grid",
+    "team-bio",
+    "pricing-table",
+    "roadmap",
+    "product-feature",
+    "executive-summary",
+    "key-takeaway",
+    "chapter-recap",
+    "qa-discussion",
+    "single-message-statement",
+    "one-column-explainer",
+    "case-study",
+    "pros-cons",
+    "feature-comparison-matrix",
+    "venn-overlap",
+    "decision-tree",
+    "kpi-scorecard",
+    "dashboard",
+    "waterfall-bridge",
+    "benchmark-target-table",
+    "heatmap-cohort",
+    "risk-heatmap",
+    "forecast-scenario",
+    "swimlane-process",
+    "gantt-project-plan",
+    "circular-lifecycle",
+    "customer-journey",
+    "org-chart",
+    "capability-map",
+    "logic-tree",
+    "hub-and-spoke",
+    "architecture-stack",
+    "ecosystem-map",
+    "network-dependency-map",
+    "wheel-radial",
+    "geographic-map",
+    "screenshot-walkthrough",
+    "market-size",
+    "persona-grid",
+    "competitive-landscape",
+    "business-model-canvas",
+    "customer-logos",
+    "executive-decision",
+    "status-rag",
+    "raci-matrix",
+    "action-plan",
+    "assumptions-dependencies",
+    "appendix-index",
+    "detailed-data-table"
+  ],
+  chartTypes: [
+    "100pct-stacked-area-3x",
+    "100pct-stacked-bar-3x",
+    "100pct-stacked-column-3x",
+    "area",
+    "bar",
+    "box-and-whisker",
+    "column",
+    "doughnut",
+    "filled-radar",
+    "funnel",
+    "histogram",
+    "line",
+    "line-with-markers",
+    "pareto",
+    "pie",
+    "radar",
+    "radar-with-markers",
+    "scatter",
+    "stacked-area-3x",
+    "stacked-bar-3x",
+    "stacked-column-3x",
+    "stacked-line-3x",
+    "stacked-line-with-markers-3x",
+    "treemap",
+    "waterfall",
+    "world",
+    "100pct-bullet-bar",
+    "100pct-bullet-bar-2x",
+    "100pct-bullet-bar-3x",
+    "100pct-bullet-column",
+    "100pct-bullet-column-2x",
+    "100pct-bullet-column-3x",
+    "100pct-progress-bar",
+    "100pct-stacked-area-2x",
+    "100pct-stacked-bar-2x",
+    "100pct-stacked-column-2x",
+    "australia",
+    "box-and-whisker-2x",
+    "box-and-whisker-3x",
+    "bullet-bar",
+    "bullet-bar-2x",
+    "bullet-bar-3x",
+    "bullet-column",
+    "bullet-column-2x",
+    "bullet-column-3x",
+    "canada",
+    "clustered-bar-2x",
+    "clustered-column",
+    "dot-plot",
+    "dot-plot-2x",
+    "dot-plot-3x",
+    "dot-plot-4x",
+    "dot-plot-5x",
+    "dot-plot-6x",
+    "dumbbell",
+    "line-2x",
+    "line-3x",
+    "line-with-high-low",
+    "line-with-high-low-and-markers",
+    "line-with-markers-2x",
+    "line-with-markers-3x",
+    "sparkline",
+    "sparkline-2x",
+    "sparkline-3x",
+    "sparkline-4x",
+    "sparkline-5x",
+    "sparkline-6x",
+    "stacked-area-2x",
+    "stacked-bar-2x",
+    "stacked-column-2x",
+    "stacked-line-2x",
+    "stacked-line-with-markers-2x",
+    "treemap-2x",
+    "treemap-3x",
+    "united-kingdom",
+    "united-states"
+  ],
+  narratives: [
+    "problem-solution",
+    "scqa",
+    "pyramid-principle",
+    "situation-complication-resolution",
+    "what-so-what-now-what",
+    "strategic-narrative",
+    "golden-circle",
+    "conference-talk",
+    "transformation-arc",
+    "pitch-deck",
+    "early-startup-pitch",
+    "venture-pitch",
+    "persuasive-sales",
+    "sparkline",
+    "company-intro",
+    "marketing-strategy",
+    "product-launch",
+    "strategic-advisory",
+    "challenge-resolution",
+    "project-proposal",
+    "vision-roadmap",
+    "failure-analysis",
+    "star-method",
+    "classic-story",
+    "heros-journey",
+    "business-narrative",
+    "change-story",
+    "rags-to-riches",
+    "underdog-victory",
+    "survival-story",
+    "educate",
+    "persuade",
+    "reveal",
+    "justice",
+    "innovation",
+    "focus",
+    "qbr",
+    "business-review",
+    "board-meeting",
+    "weekly-progress",
+    "status-update",
+    "performance-review",
+    "survey-analysis",
+    "trend-analysis",
+    "data-story",
+    "employee-review",
+    "performance-improvement-plan",
+    "capacity-planning"
+  ],
+  socialPlatforms: [
+    "linkedin",
+    "x",
+    "github",
+    "youtube",
+    "instagram",
+    "facebook",
+    "tiktok",
+    "threads",
+    "mastodon",
+    "bluesky"
+  ],
+  languages: [
+    "afrikaans",
+    "albanian",
+    "amharic",
+    "arabic",
+    "armenian",
+    "aymara",
+    "azerbaijani",
+    "bengali",
+    "berber-latin",
+    "bosnian-latin",
+    "bulgarian",
+    "catalan",
+    "cebuano",
+    "chinese-simplified",
+    "chinese-traditional",
+    "chittagonian",
+    "croatian",
+    "czech",
+    "danish",
+    "dutch",
+    "english",
+    "english-au",
+    "english-ca",
+    "english-gb",
+    "english-in",
+    "english-us",
+    "estonian",
+    "filipino",
+    "finnish",
+    "french",
+    "fulfulde",
+    "galician",
+    "georgian",
+    "german",
+    "greek",
+    "gujarati",
+    "hausa",
+    "hebrew",
+    "hindi",
+    "hungarian",
+    "igbo",
+    "indonesian",
+    "italian",
+    "japanese",
+    "kannada",
+    "kazakh",
+    "khmer",
+    "kinyarwanda",
+    "korean",
+    "kurmanji",
+    "latvian",
+    "lithuanian",
+    "macedonian",
+    "malagasy",
+    "malay",
+    "malayalam",
+    "maori",
+    "marathi",
+    "mongolian",
+    "nepali",
+    "norwegian",
+    "odia",
+    "oromo",
+    "pashto",
+    "persian",
+    "polish",
+    "portuguese",
+    "punjabi-gurmukhi",
+    "punjabi-shahmukhi",
+    "romanian",
+    "russian",
+    "serbian-cyrillic",
+    "serbian-latin",
+    "shona",
+    "slovak",
+    "slovenian",
+    "somali",
+    "spanish",
+    "swahili",
+    "swedish",
+    "tagalog",
+    "tajik",
+    "tamil",
+    "telugu",
+    "thai",
+    "turkish",
+    "ukrainian",
+    "urdu",
+    "uzbek-latin",
+    "vietnamese-quoc-ngu",
+    "xhosa",
+    "yoruba",
+    "zulu"
+  ],
+  colorSchemes: [
+    "black-and-white",
+    "bold-red",
+    "boost",
+    "burnt-orange",
+    "cool-horizon",
+    "corporate-blue",
+    "deep-purple",
+    "forest-green",
+    "golden-yellow",
+    "luxury",
+    "pastel-red",
+    "slate-gray",
+    "steel-blue",
+    "vibes"
+  ],
+  fontSchemes: [
+    "consolas",
+    "courier-new",
+    "arial",
+    "calibri",
+    "impact",
+    "lucida-sans",
+    "segoe-ui",
+    "segoe-ui-light",
+    "tahoma",
+    "trebuchet-ms",
+    "verdana",
+    "bookman",
+    "century-schoolbook",
+    "constantia",
+    "garamond",
+    "rockwell",
+    "times-new-roman",
+    "aptos",
+    "grandview",
+    "seaford",
+    "skeena",
+    "tenorite",
+    "georgia",
+    "microsoft-yahei",
+    "simsun",
+    "fangsong",
+    "yu-gothic",
+    "pmingliu",
+    "mingliu",
+    "ms-mincho",
+    "malgun-gothic",
+    "batang",
+    "gungsuh",
+    "mangal",
+    "nirmala-ui",
+    "latha",
+    "david",
+    "miriam",
+    "gisha",
+    "vrinda",
+    "shruti",
+    "tunga",
+    "kartika",
+    "kalinga",
+    "raavi",
+    "gautami",
+    "arabic-typesetting",
+    "microsoft-jhenghei",
+    "meiryo",
+    "angsana-new",
+    "aparajita",
+    "dilleniaupc",
+    "sakkal-majalla",
+    "shonar-bangla",
+    "sylfaen",
+    "traditional-arabic",
+    "montserrat",
+    "open-sans",
+    "poppins",
+    "pt-serif",
+    "raleway",
+    "roboto",
+    "noto-sans-arabic",
+    "noto-sans-armenian",
+    "noto-sans-bengali",
+    "noto-sans-devangari",
+    "noto-sans-georgian",
+    "noto-sans-gujarati",
+    "noto-sans-gurmukhi",
+    "noto-sans-hebrew",
+    "noto-sans-jp",
+    "noto-sans-kannada",
+    "noto-sans-kr",
+    "noto-sans-malayalam",
+    "noto-sans-mongolian",
+    "noto-sans-oriya",
+    "noto-sans-sc",
+    "noto-sans-tamil",
+    "noto-sans-tc",
+    "noto-sans-telugu",
+    "noto-sans",
+    "noto-sans-thai",
+    "noto-nastaliq-urdu",
+    "noto-naksh-arabic",
+    "noto-sans-ethiopic",
+    "noto-sans-khmer",
+    "nyala",
+    "daunpenh",
+    "khmer-ui"
+  ]
+};
+var deprecatedCatalogIds = {
+  "chartTypes/100pct-bullet-bar": "100pct-stacked-bar-3x",
+  "chartTypes/100pct-bullet-bar-2x": "100pct-stacked-bar-3x",
+  "chartTypes/100pct-bullet-bar-3x": "100pct-stacked-bar-3x",
+  "chartTypes/100pct-bullet-column": "100pct-stacked-column-3x",
+  "chartTypes/100pct-bullet-column-2x": "100pct-stacked-column-3x",
+  "chartTypes/100pct-bullet-column-3x": "100pct-stacked-column-3x",
+  "chartTypes/100pct-progress-bar": "100pct-stacked-bar-3x",
+  "chartTypes/100pct-stacked-area-2x": "100pct-stacked-area-3x",
+  "chartTypes/100pct-stacked-bar-2x": "100pct-stacked-bar-3x",
+  "chartTypes/100pct-stacked-column-2x": "100pct-stacked-column-3x",
+  "chartTypes/australia": "world",
+  "chartTypes/box-and-whisker-2x": "box-and-whisker",
+  "chartTypes/box-and-whisker-3x": "box-and-whisker",
+  "chartTypes/bullet-bar": "bar",
+  "chartTypes/bullet-bar-2x": "bar",
+  "chartTypes/bullet-bar-3x": "bar",
+  "chartTypes/bullet-column": "column",
+  "chartTypes/bullet-column-2x": "column",
+  "chartTypes/bullet-column-3x": "column",
+  "chartTypes/canada": "world",
+  "chartTypes/clustered-bar-2x": "bar",
+  "chartTypes/clustered-column": "column",
+  "chartTypes/dot-plot": "scatter",
+  "chartTypes/dot-plot-2x": "scatter",
+  "chartTypes/dot-plot-3x": "scatter",
+  "chartTypes/dot-plot-4x": "scatter",
+  "chartTypes/dot-plot-5x": "scatter",
+  "chartTypes/dot-plot-6x": "scatter",
+  "chartTypes/dumbbell": "scatter",
+  "chartTypes/line-2x": "line",
+  "chartTypes/line-3x": "line",
+  "chartTypes/line-with-high-low": "line",
+  "chartTypes/line-with-high-low-and-markers": "line-with-markers",
+  "chartTypes/line-with-markers-2x": "line-with-markers",
+  "chartTypes/line-with-markers-3x": "line-with-markers",
+  "chartTypes/sparkline": "line",
+  "chartTypes/sparkline-2x": "line",
+  "chartTypes/sparkline-3x": "line",
+  "chartTypes/sparkline-4x": "line",
+  "chartTypes/sparkline-5x": "line",
+  "chartTypes/sparkline-6x": "line",
+  "chartTypes/stacked-area-2x": "stacked-area-3x",
+  "chartTypes/stacked-bar-2x": "stacked-bar-3x",
+  "chartTypes/stacked-column-2x": "stacked-column-3x",
+  "chartTypes/stacked-line-2x": "stacked-line-3x",
+  "chartTypes/stacked-line-with-markers-2x": "stacked-line-with-markers-3x",
+  "chartTypes/treemap-2x": "treemap",
+  "chartTypes/treemap-3x": "treemap",
+  "chartTypes/united-kingdom": "world",
+  "chartTypes/united-states": "world"
+};
+
+// src/chart-options.ts
+var END_POSITIONS = ["center", "inside-end", "inside-base", "outside-end"];
+var STACKED_POSITIONS = ["center", "inside-end", "inside-base"];
+var POINT_POSITIONS = ["above", "below", "left", "right", "center"];
+var PIE_POSITIONS = ["center", "inside-end", "outside-end"];
+var NONE = [];
+var VALUE_CATEGORY = ["category", "value"];
+var ALL_CONTENT = ["category", "value", "percent"];
+var categoryKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "scatter", "histogram", "pareto", "box", "waterfall", "funnel"]);
+var valueKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "scatter", "histogram", "pareto", "box", "waterfall"]);
+var legendKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "pie", "doughnut", "scatter", "radar", "box"]);
+function labelSupport(target) {
+  const none = { supported: true, content: VALUE_CATEGORY, positions: NONE, defaultPosition: null, defaultOn: false };
+  switch (target.kind) {
+    case "bar":
+      return target.stacked ? { ...none, positions: STACKED_POSITIONS, defaultPosition: "center" } : { ...none, positions: END_POSITIONS, defaultPosition: "outside-end" };
+    case "line":
+    case "scatter":
+      return { ...none, positions: POINT_POSITIONS, defaultPosition: "above" };
+    case "pie":
+      return { ...none, content: ALL_CONTENT, positions: PIE_POSITIONS, defaultPosition: "outside-end" };
+    case "doughnut":
+      return { ...none, content: ALL_CONTENT };
+    // The funnel labels its bars with values and the treemap its tiles with category names by default.
+    case "funnel":
+    case "treemap":
+      return { ...none, defaultOn: true };
+    case "area":
+    case "radar":
+      return none;
+    case "histogram":
+    case "pareto":
+    case "waterfall":
+      return { ...none, positions: END_POSITIONS, defaultPosition: "outside-end" };
+    default:
+      return { ...none, supported: false, content: [] };
+  }
+}
+function chartOptionSupport(target) {
+  return {
+    axisTitles: { category: categoryKinds.has(target.kind), value: valueKinds.has(target.kind) },
+    legend: legendKinds.has(target.kind),
+    dataLabels: labelSupport(target)
+  };
+}
+var KEPT = {
+  column: { kind: "bar" },
+  "stacked-column-3x": { kind: "bar", stacked: true },
+  "100pct-stacked-column-3x": { kind: "bar", stacked: true },
+  bar: { kind: "bar" },
+  "stacked-bar-3x": { kind: "bar", stacked: true },
+  "100pct-stacked-bar-3x": { kind: "bar", stacked: true },
+  line: { kind: "line" },
+  "line-with-markers": { kind: "line" },
+  "stacked-line-3x": { kind: "line", stacked: true },
+  "stacked-line-with-markers-3x": { kind: "line", stacked: true },
+  area: { kind: "area" },
+  "stacked-area-3x": { kind: "area", stacked: true },
+  "100pct-stacked-area-3x": { kind: "area", stacked: true },
+  pie: { kind: "pie" },
+  doughnut: { kind: "doughnut" },
+  scatter: { kind: "scatter" },
+  radar: { kind: "radar" },
+  "radar-with-markers": { kind: "radar" },
+  "filled-radar": { kind: "radar" },
+  treemap: { kind: "treemap" },
+  histogram: { kind: "histogram" },
+  pareto: { kind: "pareto" },
+  "box-and-whisker": { kind: "box" },
+  waterfall: { kind: "waterfall" },
+  funnel: { kind: "funnel" },
+  world: { kind: "map" }
+};
+function chartOptionTarget(typeId) {
+  if (typeof typeId !== "string") return void 0;
+  const raw = typeId.trim().toLowerCase();
+  const id = raw === "donut" ? "doughnut" : raw;
+  const kept = deprecatedCatalogIds[`chartTypes/${id}`] ?? id;
+  const target = Object.hasOwn(KEPT, kept) ? KEPT[kept] : void 0;
+  return target ? { ...target } : void 0;
+}
+var record3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var LEGEND_POSITIONS = /* @__PURE__ */ new Set(["none", "top", "bottom", "left", "right"]);
+var CONTENT_ORDER = ["category", "value", "percent"];
+var POSITIONS = /* @__PURE__ */ new Set(["auto", "center", "inside-end", "inside-base", "outside-end", "above", "below", "left", "right"]);
+var DEFAULT_CHART_LABEL_SEPARATOR = ", ";
+function resolveChartOptions(chart, target) {
+  const result = { active: false, axisTitles: {}, diagnostics: [] };
+  if (!record3(chart)) return result;
+  const support = target ? chartOptionSupport(target) : void 0;
+  const adapt = (option, reason, message) => result.diagnostics.push({ code: "chart-option-adapted", option, reason, message });
+  const kind2 = target?.kind ?? "unknown";
+  if (record3(chart.axisTitles)) {
+    for (const axis of ["category", "value"]) {
+      const raw = chart.axisTitles[axis];
+      if (typeof raw !== "string" || !raw.trim()) continue;
+      if (support && !support.axisTitles[axis]) {
+        adapt(`axisTitles.${axis}`, "unsupported-type", `A '${kind2}' chart has no ${axis} axis to title; the ${axis} axis title is not drawn or exported.`);
+        continue;
+      }
+      result.axisTitles[axis] = raw.trim();
+    }
+  }
+  if (typeof chart.legend === "string" && LEGEND_POSITIONS.has(chart.legend)) {
+    if (support && !support.legend) adapt("legend", "unsupported-type", `A '${kind2}' chart has no legend option; the legend setting is ignored.`);
+    else result.legend = chart.legend;
+  }
+  const labels = chart.dataLabels;
+  if (labels === false && support?.dataLabels.defaultOn) result.dataLabelsOff = true;
+  if (labels === true || record3(labels)) {
+    const options = record3(labels) ? labels : {};
+    if (support && !support.dataLabels.supported) {
+      adapt("dataLabels", "unsupported-type", `A '${kind2}' chart has no data label option; data labels are not drawn or exported.`);
+    } else {
+      const allowed = support?.dataLabels.content ?? ALL_CONTENT;
+      const requested = Array.isArray(options.content) ? options.content.filter((part) => typeof part === "string" && CONTENT_ORDER.includes(part)) : ["value"];
+      const content = CONTENT_ORDER.filter((part) => requested.includes(part) && allowed.includes(part));
+      for (const part of CONTENT_ORDER) {
+        if (requested.includes(part) && !allowed.includes(part)) adapt("dataLabels.content", "unsupported-content", `A '${kind2}' chart cannot label '${part}'${part === "percent" ? " (percent exists only on pie and doughnut charts)" : ""}; it is dropped from the data labels.`);
+      }
+      if (!content.length) content.push("value");
+      const positions = support?.dataLabels.positions ?? NONE;
+      let position = support?.dataLabels.defaultPosition ?? null;
+      if (typeof options.position === "string" && POSITIONS.has(options.position) && options.position !== "auto") {
+        if (!support || positions.includes(options.position)) position = options.position;
+        else adapt("dataLabels.position", "unsupported-position", `A '${kind2}'${target?.stacked ? " stacked" : ""} chart cannot place data labels '${options.position}'; the type's default position is used.`);
+      }
+      let separator = typeof options.separator === "string" ? options.separator : DEFAULT_CHART_LABEL_SEPARATOR;
+      if (/[\r\n]/.test(separator)) {
+        separator = separator.replace(/[\r\n]+/g, " ");
+        adapt("dataLabels.separator", "unsupported-content", "A data label is one line; the line break in the separator is replaced with a space.");
+      }
+      result.dataLabels = { content, position, separator };
+    }
+  }
+  result.active = result.legend !== void 0 || result.dataLabels !== void 0 || result.dataLabelsOff === true || result.axisTitles.category !== void 0 || result.axisTitles.value !== void 0;
+  return result;
+}
+function formatChartLabelNumber(value) {
+  return String(Number(value.toPrecision(12)));
+}
+function formatChartLabelPercent(share) {
+  return `${Math.round(Number((share * 100).toPrecision(12)))}%`;
+}
+function chartLabelText(parts, content, separator = DEFAULT_CHART_LABEL_SEPARATOR) {
+  return CONTENT_ORDER.filter((part) => content.includes(part) && parts[part] !== void 0).map((part) => parts[part]).join(separator);
+}
+
+// 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 = record4(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 = record4(input);
+  const family = (value) => typeof value === "string" ? value : record4(value).family;
+  const accent = family(scheme.accent);
+  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,
+    ...typeof accent === "string" && accent ? { accent } : {}
+  };
+}
+function resolveTextStyle(style, measurement) {
+  return measurement?.resolveStyle ? measurement.resolveStyle(style) : style;
+}
+function textWidthMeasurer(style, measurement) {
+  if (!measurement) return measureText;
+  return (text2, size) => {
+    const width = measurement.measure(text2, size, style);
+    if (!Number.isFinite(width) || width < 0) throw new RangeError("Text measurement must return a finite, nonnegative width.");
+    return width;
+  };
+}
+function measureTextOutline(text2, 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(text2, 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, directions) {
+  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 placed = [];
+  let shift = 0, bottom = box.y, height = 0, overflow = false;
+  for (const [lineIndex, line] of lines.entries()) {
+    const lineAlignment = physicalAlignment(alignment, directions?.[lineIndex]), factor = lineAlignment === "right" ? 1 : lineAlignment === "center" ? 0.5 : 0;
+    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, ...directions ? { alignment: lineAlignment } : {} });
+  }
+  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 record4 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var kind = (field) => field === "items" ? "list" : field === "bullets" ? "text" : field;
+var round2 = (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 : record4(value).src;
+var finite = (value, min, max) => typeof value === "number" && Number.isFinite(value) && value >= min && value <= max ? value : void 0;
+var pathNumber = (value) => String(round2(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, rtl = false) {
+  const own = record4(slide.design), deck = record4(record4(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 ? record4(configured) : void 0;
+  const alignment = typeof layout.slideImageAlignment === "string" ? layout.slideImageAlignment.toLowerCase() : void 0;
+  const authoredPosition = treatment ? treatment.position : SLIDE_IMAGE_POSITIONS.find((value2) => value2 === alignment) ?? "background";
+  if (!SLIDE_IMAGE_POSITIONS.includes(authoredPosition)) return void 0;
+  const mirrorSide = (side) => !rtl ? side : side === "left" ? "right" : side === "right" ? "left" : side;
+  const position = mirrorSide(authoredPosition);
+  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: round2(width * share), height: round2(height * share) };
+  const region = position === "left" ? { x: 0, y: 0, width: band.width, height } : position === "right" ? { x: round2(width - band.width), y: 0, width: band.width, height } : position === "top" ? { x: 0, y: 0, width, height: band.height } : position === "bottom" ? { x: 0, y: round2(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: round2(box.x), y: round2(box.y), width: round2(box.width), height: round2(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 = record4(t.border), borderWidth = finite(border.width, 0, 64);
+  if (border.color !== void 0 && borderWidth) result.border = { color: border.color, width: round2(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 (record4(t.recolor).dark !== void 0 && record4(t.recolor).light !== void 0) result.recolor = { type: "duotone", dark: t.recolor.dark, light: t.recolor.light };
+  const overlay = record4(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) ? mirrorSide(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: round2(box.height * part) } : edge === "bottom" ? { ...box, y: round2(box.y + box.height * (1 - part)), height: round2(box.height * part) } : edge === "left" ? { ...box, width: round2(box.width * part) } : { ...box, x: round2(box.x + box.width * (1 - part)), width: round2(box.width * part) };
+      result.overlay = { color: overlay.color, opacity: overlayOpacity, box: bandBox, shape: edge ? slideImageShape("rectangle", bandBox) : result.shape };
+    }
+  }
+  return result;
+}
+var LOGO_LOCKUP_CHAINS = {
+  dark: ["light", "default", "stackedLight", "stacked", "wordmarkLight", "wordmark", "iconLight", "icon", "dark", "stackedDark", "wordmarkDark", "iconDark"],
+  light: ["dark", "default", "stackedDark", "stacked", "wordmarkDark", "wordmark", "iconDark", "icon", "light", "stackedLight", "wordmarkLight", "iconLight"]
+};
+var LOGO_SET_KEYS = new Set(LOGO_LOCKUP_CHAINS.dark);
+function resolveLogo(presentation, slide, options = {}) {
+  const slot = options.slot === "icon" || options.slot === "stacked" ? options.slot : "lockup";
+  if (options.slot !== void 0 && slot !== options.slot) throw new RangeError("Logo slot must be lockup, icon or stacked.");
+  const tone = options.onDark === true ? "dark" : "light";
+  const lockup = LOGO_LOCKUP_CHAINS[tone];
+  const chain = slot === "icon" ? [tone === "dark" ? "iconLight" : "iconDark", "icon", ...lockup] : slot === "stacked" ? [tone === "dark" ? "stackedLight" : "stackedDark", "stacked", ...lockup] : lockup;
+  const usable = (value) => {
+    const source = assetSource(value);
+    return typeof source === "string" && source.length > 0;
+  };
+  const pick = (value, path) => {
+    if (value === void 0 || value === null || value === false) return null;
+    if (typeof value === "string" || typeof value === "object" && !Array.isArray(value) && "src" in record4(value)) {
+      return usable(value) ? { source: value, path, variant: "default", slot } : null;
+    }
+    const set = record4(value);
+    if (!Object.keys(set).some((key) => LOGO_SET_KEYS.has(key))) return null;
+    for (const key of chain) {
+      const variant = set[key];
+      if (variant !== void 0 && usable(variant)) return { source: variant, path: `${path}.${key}`, variant: key, slot };
+    }
+    return null;
+  };
+  const deck = record4(presentation), slideIndex = Number.isSafeInteger(options.slideIndex) && options.slideIndex >= 0 ? options.slideIndex : 0;
+  const own = pick(record4(record4(slide).design).logo, `slides.${slideIndex}.design.logo`);
+  if (own) return own;
+  const shared = pick(record4(deck.design).logo, "design.logo");
+  if (shared) return shared;
+  const organizations = Array.isArray(deck.organization) ? deck.organization : [deck.organization];
+  const primaryIndex = organizations.findIndex((item) => record4(item).role === "primary");
+  const index = primaryIndex >= 0 ? primaryIndex : organizations.findIndex(Boolean);
+  if (index < 0) return null;
+  return pick(record4(organizations[index]).logo, Array.isArray(deck.organization) ? `organization.${index}.logo` : "organization.logo");
+}
+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 = record4(input), width = options.width ?? 1280, height = options.height ?? 720, scale = Math.min(width, height) / 720;
+  const settings = { ...record4(record4(options.layout).composition), ...record4(slide.composition) };
+  assertComposition(settings);
+  const furnitureRtl = (options.direction ?? resolveSlideDirection(options.presentation, options.slideIndex)) === "rtl";
+  const minimum = snapFontSizeUp((settings.minFontSize ?? 16) * scale), size = gridFontSize(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) => record4(item).role === "primary"), organizationIndex = primaryIndex >= 0 ? primaryIndex : organizations.findIndex(Boolean);
+  const organization = record4(organizations[organizationIndex]), organizationRoot = Array.isArray(options.presentation?.organization) ? `organization.${organizationIndex}` : "organization", organizationPath = `${organizationRoot}.name`;
+  const inlinePlatforms = record4(record4(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 = record4(slide.design)[kind2] !== void 0, value = local ? record4(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 side = furnitureRtl && zone !== "center" ? zone === "left" ? "right" : "left" : zone;
+      const content = record4(record4(value)[zone]), path = `${root}.${zone}`, x = width * (0.07 + (furnitureRtl ? 2 - index : index) * 0.3), zoneWidth = width * 0.26, zoneParts = [];
+      let y = 0;
+      const add = (field, text2, generated = false, sourcePath, extras = {}) => {
+        if (text2 === void 0) return;
+        if (typeof text2 !== "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(text2, { 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(text2.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 }, side, 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, side, 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: text2, style, requestedFontSize: size, minFontSize: minimum, box, alignment: side, 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;
+      };
+      const imageBox = (source) => {
+        const imageHeight = Math.max(32 * scale, Math.min(height * 0.05, 72 * scale)), imageWidth = Math.min(zoneWidth, imageHeight * (intrinsicImageAspect(source, record4(options.presentation).assets) ?? 1));
+        return { x: side === "left" ? x : side === "center" ? x + (zoneWidth - imageWidth) / 2 : x + zoneWidth - imageWidth, y, width: imageWidth, height: imageHeight };
+      };
+      if (content.logo === true) {
+        const resolved = resolveLogo(options.presentation, slide, { slot: "icon", onDark: options.darkBackground, slideIndex: options.slideIndex });
+        if (resolved) {
+          const box = imageBox(resolved.source);
+          zoneParts.push({ type: "image", kind: kind2, zone, field: "logo", path: `${path}.logo`, sourcePath: resolved.path, generated: true, image: resolved.source, box, alignment: side });
+          y += box.height;
+        } else error(`${path}.logo`, "Generated logo needs design.logo or a primary organization logo.", "unresolved-content");
+      }
+      if (content.image !== void 0) {
+        const box = imageBox(content.image);
+        zoneParts.push({ type: "image", kind: kind2, zone, field: "image", path: `${path}.image`, sourcePath: `${path}.image`, generated: false, image: content.image, box, alignment: side });
+        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(record4(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" });
+var WRAP_TOLERANCE = 0.01;
+var HANGING_SPACE = /[^\S\r\n\u00a0\u202f\ufeff]/u;
+function measureText(text2, fontSize) {
+  let units = 0;
+  for (const character of text2) {
+    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(text2, width, fontSize, measure = measureText) {
+  return fitSourceText(text2, { width, height: Number.MAX_VALUE }, fontSize, fontSize, 1, measure, true, false).lines;
+}
+function fitText(text2, box, requestedSize = 25, minFontSize = 16, measure = measureText, direction) {
+  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(text2, box, Math.max(requestedSize, minFontSize), minFontSize, 1, measure, true, true, direction);
+}
+var FONT_SIZE_GRID_PER_PX = 75;
+var FONT_GRID_EPSILON = 1e-6;
+function snapFontSizeDown(px) {
+  return Math.max(px > 0 ? 1 : -Infinity, Math.floor(px * FONT_SIZE_GRID_PER_PX + FONT_GRID_EPSILON)) / FONT_SIZE_GRID_PER_PX;
+}
+function snapFontSizeUp(px) {
+  return Math.max(px > 0 ? 1 : -Infinity, Math.ceil(px * FONT_SIZE_GRID_PER_PX - FONT_GRID_EPSILON)) / FONT_SIZE_GRID_PER_PX;
+}
+function gridFontSize(raw, minimum) {
+  return Math.max(snapFontSizeUp(minimum), snapFontSizeDown(raw));
+}
+function fitAtSizes(layout, requested, minimum, step = 1, snap = true) {
+  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 raw = start - trial * step, last = trial === 64 || raw <= minimum;
+    const size = !snap ? last ? minimum : Math.max(minimum, raw) : last ? snapFontSizeUp(minimum) : gridFontSize(raw, minimum), result = layout(size);
+    if (!result.overflow || last) 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 = snapFontSizeUp((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, text2, outputStart) => ({ path: sourcePath, start: 0, end: text2.length, outputStart, outputEnd: outputStart + text2.length });
+  const add = (role, text2, sources, area, fontSize, fontFamily, fontWeight, partPath) => {
+    const requestedStyle = { fontFamily, fontWeight, italic: false, path: partPath };
+    const style = resolveTextStyle({ ...requestedStyle }, options.textMeasurement);
+    const requestedFontSize = gridFontSize(fontSize * scale, minimum);
+    const part = { role, path: partPath, text: text2, sources, box: area, requestedFontSize, minFontSize: minimum, requestedStyle, style };
+    parts.push(part);
+    return part;
+  };
+  let footer = "";
+  const footerSources = [];
+  for (const field of ["attribution", "source"]) {
+    const text2 = quote[field];
+    if (!text2) continue;
+    if (footer) footer += " - ";
+    footerSources.push(source(`${path}.${field}`, text2, footer.length));
+    footer += text2;
+  }
+  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?.accent ?? 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), options.direction) : 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 = snapFontSizeUp((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 requestedAlignment = options.align ?? "left";
+  if (!["left", "center", "right"].includes(requestedAlignment)) 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 text2 = 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: text2,
+      sources: [{ path, value: sourceValue, start: 0, end: text2.length }],
+      visible: role === "value" || text2.length > 0,
+      linePositions: [],
+      box: { ...box, height: 0 },
+      requestedFontSize: gridFontSize(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 metricDirection = options.direction === "rtl" ? paragraphDirection(["label", "description", "unit"].map((role) => parts.find((part) => part.role === role)?.text).find(Boolean) ?? primary.text, "rtl") : void 0;
+  const alignment = physicalAlignment(requestedAlignment, metricDirection);
+  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 cache2 = /* @__PURE__ */ new Map();
+  const measure = (part, size, width) => {
+    const key = JSON.stringify([part.role, size, width]);
+    let fit = cache2.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), options.direction);
+      fit = place(part, fit, width);
+      if (!Number.isFinite(occupied(fit))) throw new RangeError("Metric text layout exceeds finite coordinates.");
+      cache2.set(key, fit);
+    }
+    return fit;
+  };
+  const fitValue = (area, singleLine) => {
+    if (!usable(area)) return void 0;
+    for (let step = 0; step <= 76; step++) {
+      const size = gridFontSize(primary.requestedFontSize - step * scale, minimum);
+      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, gridFontSize(part.requestedFontSize - reduction * scale, minimum), 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 = snapFontSizeUp((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, rtl = options.direction === "rtl";
+  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, text2, partPath, size, weight, eventIndex) => {
+    if (text2 === void 0) return;
+    const requestedStyle = { fontFamily: fonts.body, fontWeight: weight, italic: false, path: partPath };
+    source.push({ role, eventIndex, path: partPath, text: text2, sources: [{ path: partPath, start: 0, end: text2.length }], box: { ...box }, alignment: "center", requestedFontSize: gridFontSize(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 cache2 = /* @__PURE__ */ new Map();
+  const measure = (part, size, width, alignment) => {
+    const key = JSON.stringify([part.path, size, width, alignment]);
+    let measured = cache2.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), options.direction);
+    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, fit.directions) : 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 };
+    cache2.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, gridFontSize(part.requestedFontSize - reduction * scale, minimum), 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, measured.fit.directions) : 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 + (rtl ? count - 1 - index : 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 = rtl ? box.x + box.width - radius : box.x + radius, textX = rtl ? box.x : 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 = rtl ? { x1: Math.min(first.x, last.x), y1: first.y, x2: Math.max(first.x, last.x), y2: last.y } : { 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(text2, box, size, minimum, step, measure, direction) {
+  return fitSourceText(text2, box, size, minimum, step, measure, false, true, direction);
+}
+function fitSourceText(text2, box, size, minimum, step, measure, prose = false, snap = true, direction) {
+  const directionAt = direction === "rtl" ? paragraphDirectionAt(text2, "rtl") : void 0;
+  const layout = (fontSize) => {
+    const tabWidth = measure(" ", fontSize) * 4;
+    if (!Number.isFinite(tabWidth) || text2.includes("	") && tabWidth <= 0) throw new RangeError("Text tabs require a positive finite measured space advance.");
+    const measureLine = (start2, end2, record5 = false) => {
+      let x = 0, offset = start2;
+      const segments = [];
+      for (const [index, segment] of text2.slice(start2, end2).split("	").entries()) {
+        if (index) {
+          const next = (Math.floor(x / tabWidth + 1e-9) + 1) * tabWidth;
+          if (record5) segments.push({ kind: "tab", start: offset, end: offset + 1, x, width: next - x });
+          x = next;
+          offset++;
+        }
+        if (segment) {
+          const advance = measure(segment, fontSize);
+          if (record5) 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, hangFrom = -1;
+    const push = (last, nextStart, boundary) => {
+      const measured = measureLine(start, last, true);
+      if (hangFrom >= 0 && hangFrom < last) measured.width = measureLine(start, hangFrom).width;
+      hangFrom = -1;
+      sourceLines.push({ start, end: last, nextStart, boundary, ...measured });
+      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 text2.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 + WRAP_TOLERANCE) {
+        end = b;
+        continue;
+      }
+      if (prose && end > start && /\S/u.test(text2.slice(start, end)) && HANGING_SPACE.test(token[0][0])) {
+        if (hangFrom < 0) hangFrom = end;
+        end = b;
+        continue;
+      }
+      if (end > start && /\S/u.test(text2.slice(start, end))) push(a, a, "soft");
+      if (width(start, b) <= box.width + WRAP_TOLERANCE) {
+        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) => text2.slice(line.start, line.end)),
+      sourceLines,
+      fontSize,
+      lineHeight,
+      tabSize: 4,
+      tabWidth,
+      ...directionAt ? { directions: sourceLines.map((line) => directionAt(line.start)) } : {},
+      overflow: sourceLines.length * lineHeight > box.height + 0.01 || sourceLines.some((line) => line.width > box.width + 0.01)
+    };
+  };
+  return fitAtSizes(layout, size, minimum, step, snap);
+}
+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 = snapFontSizeUp((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, text2, 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: text2,
+      sources: generated ? [] : [{ path: partPath, start: 0, end: text2.length }],
+      generated,
+      box: { ...inner },
+      requestedFontSize: gridFontSize((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, minFontSize);
+  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, minimum = 0) {
+  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);
+    const marker = options.citationMarker && options.style.path && run.text ? options.citationMarker(`${options.style.path}.${runIndex}`) : void 0;
+    return { run, runIndex, start, end: offset, style, ...marker ? { marker } : {} };
+  });
+  const whole = source.map((entry) => entry.run.text).join("");
+  const paint = (raw) => raw >= minimum - 1e-6 ? gridFontSize(raw, minimum) : snapFontSizeDown(raw);
+  const directionAt = options.direction === "rtl" ? paragraphDirectionAt(whole, "rtl") : void 0;
+  const layout = (rawFontSize) => {
+    const fontSize = paint(rawFontSize), ratio = rawFontSize / 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 text2 = whole.slice(a, b), normalSize = entry.run.fontSize !== void 0 ? entry.run.fontSize * 4 / 3 * ratio : fontSize;
+        const script = entry.run.superscript || entry.run.subscript;
+        const size = script ? paint(normalSize * 0.7) : paint(normalSize), 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 text2.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;
+          }
+        }
+        if (entry.marker && b === entry.end) {
+          const markerSize = Math.round(normalSize * CITATION_MARKER_SCALE * FONT_SIZE_GRID_PER_PX) / FONT_SIZE_GRID_PER_PX, width2 = measure(entry.marker, markerSize);
+          result.push({ kind: "marker", text: entry.marker, runIndex: entry.runIndex, start: entry.run.text.length, end: entry.run.text.length, x, width: width2, fontSize: markerSize, nominalSize: normalSize, baselineShift: -normalSize * CITATION_MARKER_RAISE, 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 = [], hung = /* @__PURE__ */ new Map();
+    let lineStart = 0, lineEnd = 0, hangFrom = -1;
+    const push = (end) => {
+      if (hangFrom >= 0) hung.set(ranges.length, hangFrom);
+      hangFrom = -1;
+      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 + WRAP_TOLERANCE) {
+        lineEnd = end;
+        continue;
+      }
+      if (HANGING_SPACE.test(match[0][0]) && lineEnd > lineStart && /\S/u.test(whole.slice(lineStart, lineEnd))) {
+        if (hangFrom < 0) hangFrom = lineEnd;
+        lineEnd = end;
+        continue;
+      }
+      if (lineEnd > lineStart) push(start);
+      if (width(start, end) <= box.width + WRAP_TOLERANCE) {
+        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 + WRAP_TOLERANCE) push(start + index);
+        lineEnd = next;
+      }
+    }
+    if (hangFrom >= 0) hung.set(ranges.length, hangFrom);
+    ranges.push({ start: lineStart, end: lineEnd });
+    let y = 0;
+    const richLines = ranges.map((range, rangeIndex) => {
+      const parts = fragments(range.start, range.end), shown = hung.get(rangeIndex) ?? 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: shown === range.end ? parts.reduce((sum, p) => sum + p.width, 0) : width(range.start, shown), 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),
+      ...directionAt ? { directions: ranges.map((range) => directionAt(range.start)) } : {}
+    };
+  };
+  return layout;
+}
+var PICTURE_BULLET_SCALE = 0.65;
+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 text2 = 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(text2)) || 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;
+    const plain = (value2) => typeof value2 === "string" ? value2 : value2.map((run) => typeof run === "string" ? run : run.text).join("");
+    const direction = options.direction === "rtl" ? paragraphDirection(plain(text2), "rtl") : void 0;
+    return { index, level, direction, value: text2, descriptionValue: description, textPath: base ? base + (object ? ".text" : "") : void 0, descriptionPath: base ? base + ".description" : void 0, runs: runs(text2), descriptionRuns: description === void 0 ? void 0 : runs(description) };
+  });
+  const numbers = options.numbering === void 0 ? void 0 : listNumbers(input, options.numbering);
+  const markerStyleFor = (item) => {
+    const first = item.runs.map((run) => typeof run === "string" ? { text: run } : run).find((run) => run.text);
+    return { ...options.style, path: item.textPath, fontWeight: first?.bold === void 0 ? options.style.fontWeight : first.bold ? 700 : 400, italic: first?.italic ?? options.style.italic };
+  };
+  const layout = (fontSize) => {
+    let y = box.y, overflow = false;
+    const entries = [], lines = [], directions = [];
+    const markerStyles = numbers ? source.map((item) => resolveTextStyle(markerStyleFor(item), options.textMeasurement)) : [];
+    const markerWidths = numbers ? numbers.map((number, index) => textWidthMeasurer(markerStyles[index], options.textMeasurement)(number.text, fontSize)) : [];
+    const hanging = numbers ? Math.max(fontSize * 1.1, Math.max(0, ...markerWidths) + fontSize * 0.3) : fontSize * 1.1;
+    for (const item of source) {
+      const rtl = item.direction === "rtl";
+      const indent = hanging, offset = Math.min(box.width, item.level * indent), x = rtl ? box.x : box.x + offset + indent, width = Math.max(1, rtl ? box.width - offset - indent : 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 text2 = richTextLayouter(item.runs, textBox, requestedSize, { ...options, style }, minFontSize)(fontSize);
+      textBox.height = text2.height;
+      lines.push(...text2.lines);
+      if (options.direction === "rtl") directions.push(...text2.directions ?? []);
+      y += text2.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 } }, minFontSize)(fontSize * 0.82);
+        descriptionBox.height = description.height;
+        lines.push(...description.lines);
+        if (options.direction === "rtl") directions.push(...description.directions ?? []);
+        y += description.height;
+      }
+      overflow ||= text2.overflow || !!description?.overflow;
+      const number = numbers?.[item.index];
+      const marker = { text: number ? number.text : ["\u2022", "\u25E6", "\u25AA"][item.level % 3], x: rtl ? box.x + box.width - offset : box.x + offset, y: textBox.y + (text2.richLines[0]?.baseline ?? fontSize), fontSize, style: number ? markerStyles[item.index] : resolveTextStyle(style, options.textMeasurement), indent, ...number ? { number, width: markerWidths[item.index] } : {}, ...rtl ? { anchor: "end" } : {} }, side = fontSize * PICTURE_BULLET_SCALE;
+      entries.push({
+        index: item.index,
+        level: item.level,
+        value: item.value,
+        descriptionValue: item.descriptionValue,
+        textPath: item.textPath,
+        descriptionPath: item.descriptionPath,
+        text: text2,
+        textBox,
+        description,
+        descriptionBox,
+        marker,
+        ...item.direction ? { direction: item.direction } : {},
+        ...options.bulletImage && !number ? { bulletImage: options.bulletImage, bulletBox: { x: rtl ? marker.x - side : marker.x, y: marker.y - side, width: side, height: side } } : {}
+      });
+      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, ...options.direction === "rtl" ? { directions } : {} };
+  };
+  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 = record4(item);
+    return `\u2022 ${flatten(item)}${entry.description ? `
+${flatten(entry.description)}` : ""}`;
+  }).join("\n");
+  if (field === "code") return flatten(record4(value).source ?? value);
+  if (field === "quote") return flatten(record4(value).text ?? value);
+  return void 0;
+}
+function layoutTable(value, box, options = {}) {
+  const scale = options.scale ?? 1, minimum = snapFontSizeUp((options.minFontSize ?? 16) * scale), requested = gridFontSize(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, direction: options.direction }) : fitText(flatten(cell.value), textBox, requested, min, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement), options.direction);
+  };
+  const textHeight = (fit) => "height" in fit ? fit.height : fit.lines.length * fit.lineHeight;
+  const required = (cell, natural2) => {
+    const floor = cellMinimum(cell), size = gridFontSize(natural2 ? Math.max(requested, floor) : 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 }, minimum)(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 + (options.direction === "rtl" ? columnCount - cell.column - cell.colSpan : 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, ...fit.directions ? { direction: fit.directions[0] } : {} });
+  }
+  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 = record4(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 = record4(input), layout = record4(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 deckDirection = options.direction ?? resolveSlideDirection(options.presentation, options.slideIndex);
+  const rtl = deckDirection === "rtl", textDirection = rtl ? "rtl" : void 0;
+  const hasCards = record4(slide.design).contentBox ?? options.contentBox ?? false;
+  const composition = { ...record4(layout.composition), ...record4(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 = snapFontSizeUp((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.");
+  let coverGroup = false;
+  const alignmentFor = (field) => (field === "title" || coverGroup && (field === "tag" || field === "subtitle") && record4(slide.design).contentAlignment === void 0 ? record4(slide.design).titleAlignment ?? options.titleAlignment : record4(slide.design).contentAlignment ?? options.contentAlignment) ?? "left";
+  const styleFor = (field, path2) => resolveTextStyle({
+    fontFamily: (field === "title" ? options.fonts?.heading : field === "code" ? options.fonts?.code : field === "tag" ? options.fonts?.accent ?? options.fonts?.body : options.fonts?.body) ?? (field === "code" ? "monospace" : "sans-serif"),
+    fontWeight: field === "title" ? 700 : 400,
+    path: path2
+  }, options.textMeasurement);
+  const slideDesign = record4(slide.design), deckDesign = record4(record4(options.presentation).design);
+  const designHint = (field) => slideDesign[field] !== void 0 ? { value: slideDesign[field], path: `slides.${options.slideIndex ?? 0}.design.${field}` } : deckDesign[field] !== void 0 ? { value: deckDesign[field], path: `design.${field}` } : void 0;
+  const listBullet = designHint("listBullet");
+  const bulletImage = listBullet?.value === "image" ? (() => {
+    const resolved = resolveLogo(options.presentation, slide, { slot: "icon", onDark: options.darkBackground, slideIndex: options.slideIndex });
+    return resolved ? { source: resolved.source, path: resolved.path } : void 0;
+  })() : void 0;
+  const widthFor = (field, path2) => textWidthMeasurer(styleFor(field, path2), options.textMeasurement);
+  const citations = slideCitations(slide, options.slideIndex ?? 0, options.presentation);
+  const citationMarker = citations ? (runPath) => citations.markers.get(runPath) : void 0;
+  const richOptions = (style) => ({ style, textMeasurement: options.textMeasurement, ...citationMarker ? { citationMarker } : {}, ...rtl ? { direction: "rtl" } : {} });
+  const fitPlacedText = (field, value, text2, box, size, minimum, path2, explicitAlignment) => {
+    const style = styleFor(field, path2), rich = field === "text" && Array.isArray(value);
+    if (!options.textMeasurement?.outlineBounds) return rich ? fitRichText(value, box, size, minimum, richOptions(style)) : fitText(text2, box, size, minimum, textWidthMeasurer(style, options.textMeasurement), textDirection);
+    const alignment = explicitAlignment ?? alignmentFor(field);
+    const richLayout = rich ? richTextLayouter(value, box, size, richOptions(style), minimum) : void 0;
+    const measure = textWidthMeasurer(style, options.textMeasurement), floor = snapFontSizeUp(rich ? richMinimum(value, size, minimum) : minimum), start = Math.max(size, floor);
+    for (let trial = 0; trial <= 64; trial++) {
+      const raw = start - trial * scale, last = trial === 64 || raw <= floor, fontSize = last ? floor : gridFontSize(raw, floor);
+      const fit = richLayout ? richLayout(fontSize) : fitText(text2, box, fontSize, fontSize, measure, textDirection);
+      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(text2.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, fit.directions), result = { ...fit, placement, overflow: fit.overflow || placement.overflow };
+      if (!result.overflow || last) return result;
+    }
+    throw new Error("Text placement did not evaluate its bounded floor trial.");
+  };
+  const fitContent = (field, value, text2, box, size, minimum, path2, numbering) => field === "text" ? fitPlacedText(field, value, text2, box, size, minimum, path2) : field === "items" || field === "bullets" ? fitList(value, box, size, minimum, { ...richOptions(styleFor(field, path2)), ...numbering !== void 0 ? { numbering } : bulletImage ? { bulletImage } : {} }) : fitText(text2, box, size, minimum, widthFor(field, path2), field === "code" ? void 0 : textDirection);
+  const path = `slides.${options.slideIndex ?? 0}`;
+  const annotationFit = (value, box, requestedSize, minFontSize, fitPath, alignment) => fitPlacedText("text", value, annotationText(value), box, requestedSize, minFontSize, fitPath, alignment);
+  const annotationOptions = { scale, minFontSize: minSize, fit: annotationFit, textStyle: (fitPath) => styleFor("text", fitPath) };
+  const slideImageDiagnostics = [];
+  const slideImage = resolveSlideImage(slide, layout, options.presentation, width, height, path, padding, scale, slideImageDiagnostics, rtl);
+  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);
+  let 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);
+  let footnotes;
+  if (citations) {
+    footnotes = layoutFootnotes(citations, { ...annotationOptions, x: area.left + padding, width: area.right - area.left - padding * 2, bottom: bodyBottom, maxHeight: Math.max(minSize * 1.22 + 2 * scale, (bodyBottom - headingTop) * FOOTNOTE_MAX_RATIO), path });
+    diagnostics.push(...footnotes.diagnostics);
+    bodyBottom = footnotes.box.y - gap * 0.5;
+  }
+  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(record4(slide[key]))) || !emptyPayload(slide.blocks) || fields.some((field) => !emptyPayload(slide[field]));
+  const isCover = !hasBodyPayload && (headingOnlyLayout || !layout.id && !layoutPlaceholders.some((placeholder) => !headings.has(placeholder.type ?? "")));
+  coverGroup = isCover;
+  let logo;
+  if (isCover) {
+    const resolved = resolveLogo(options.presentation, slide, { slot: "lockup", onDark: options.darkBackground, slideIndex: options.slideIndex });
+    if (resolved) {
+      const logoHeight = 56 * scale;
+      const logoWidth = Math.max(scale, Math.min(4 * logoHeight, area.right - area.left - 2 * padding));
+      const box = { x: round2(rtl ? area.right - padding - logoWidth : area.left + padding), y: round2(headingTop), width: round2(logoWidth), height: round2(logoHeight) };
+      logo = { box, slot: "lockup", path: resolved.path, source: resolved.source, variant: resolved.variant, anchor: rtl ? "right" : "left" };
+    }
+  }
+  let y = logo ? logo.box.y + logo.box.height + gap : 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 text2 = fitPlacedText(field, slide[field], String(slide[field]), box, requested, minSize, `${path}.${field}`);
+    box.height = Math.min(maxHeight, Math.max(text2.lines.length * text2.lineHeight, text2.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: text2, 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 = record4(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(record4(block), `${basePath}.blocks.${index}`, depth + 1, [...ancestors, host]))
+      }];
+    }
+    const captioned = host.caption !== void 0 ? fields.filter((field) => host[field] !== void 0 && CAPTIONABLE_FIELDS.includes(field)) : [];
+    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], ...host.numbering !== void 0 && (field === "items" || field === "bullets") ? { numbering: host.numbering } : {} },
+      ...captioned.length === 1 && captioned[0] === field ? { caption: host.caption, captionPath: `${basePath}.caption` } : {}
+    }));
+  };
+  const regionsInReadingOrder = visualReadingOrder(regions.map((key) => ({ key, box: regionBox(regionParts(key), contentBox, gap) }))).map((entry) => entry.key);
+  const pending = regions.length ? regionsInReadingOrder.flatMap((key) => collect(record4(slide[key]), `${path}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => collect(record4(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: round2(box.x), y: round2(box.y), width: round2(box.width), height: round2(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,
+    direction: textDirection
+  });
+  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"),
+    direction: textDirection
+  });
+  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,
+    direction: textDirection
+  });
+  const captionOf = (node, box) => node.caption !== void 0 && node.captionPath ? layoutCaption(node.caption, box, node.captionPath, annotationOptions) : void 0;
+  const leafScore = (node, box, settings, penalties) => {
+    box = payloadBox(box);
+    const captioned = captionOf(node, box);
+    if (captioned) box = captioned.mediaBox;
+    const text2 = contentText(node.field, node.value);
+    let score = Math.abs(Math.log(box.width / box.height / 1.6)) + (captioned?.overflow ? 1e3 : 0);
+    if (penalties) {
+      penalties.cellProportions += Math.abs(Math.log(box.width / box.height / 1.6));
+      if (captioned?.overflow) penalties.textOverflow += 1e3;
+    }
+    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 (text2) {
+      const fit = fitContent(node.field, node.value, text2, box, 25 * scale, snapFontSizeUp((settings.minFontSize ?? 16) * scale), node.path, node.payload.numbering);
+      const reduction = Math.max(0, snapFontSizeDown(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, recorded = true) => {
+    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 && recorded ? [] : 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;
+        }
+      }
+    }
+    if (recorded) decisions?.push({
+      path: containerPath,
+      mode: hasRegions ? "regions" : mode,
+      reason: hasRegions ? "promoted-regions" : settings === rootSettings && chartPrimary ? "chart-primary" : mode === "auto" ? "lowest-score" : "configured-mode",
+      ...hasRegions ? {} : { selectedColumns: cols },
+      candidates: candidates ?? []
+    });
+    const grid = gridGeometry(count, area2, cols, actualGap, settings.weights ?? [], mode === "column");
+    const mirrored = (box) => rtl ? { ...box, x: area2.x + area2.width - (box.x - area2.x) - box.width } : box;
+    const boxes = grid.boxes.map(mirrored);
+    if (recorded && !hasRegions) flows.push({ path: containerPath, box: { ...area2 }, composition: { ...settings }, columns: rtl ? grid.columns.map((track) => ({ offset: area2.width - track.offset - track.size, size: track.size })) : grid.columns, rows: grid.rows, gap: grid.gap, itemCount: nodes.length, slotCount: count });
+    nodes.forEach((node, index) => {
+      let box = node.region ? mirrored(regionBox(node.region, area2, actualGap)) : boxes[index];
+      if (node.children) {
+        const own = inheritedSettings(settings, node.composition), inner = inset(box, own);
+        if (!node.synthetic) 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, !node.synthetic);
+      } else {
+        const frameBox = hasCards ? acceptedBox(box) : void 0;
+        box = payloadBox(box);
+        const caption = captionOf(node, box);
+        if (caption) {
+          box = caption.mediaBox;
+          diagnostics.push(...caption.diagnostics);
+        }
+        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 text2 = internal ? body?.fit : textValue !== void 0 ? fitContent(node.field, node.value, textValue, box, 25 * scale, snapFontSizeUp((settings.minFontSize ?? 16) * scale), node.path, node.payload.numbering) : 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: text2,
+          textStyle: body?.style ?? styleFor(node.field, node.path),
+          composition: settings,
+          alignment: alignmentFor(node.field),
+          ...quoteLayout ? { quoteLayout } : {},
+          ...codeLayout ? { codeLayout } : {},
+          ...metricLayout ? { metricLayout } : {},
+          ...timelineLayout ? { timelineLayout } : {},
+          ...bulletImage && node.payload.numbering === void 0 && (node.field === "items" || node.field === "bullets") ? { bulletImage } : {},
+          ...caption ? { caption } : {}
+        });
+        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 ownMode = record4(slide.composition).mode;
+  const direction = designHint("contentDirection")?.value;
+  const directionMode = direction === "vertical" ? "column" : direction === "horizontal" ? "row" : void 0;
+  const layoutDirectionMode = layout.slideLayoutDirection === "Vertical" ? "column" : layout.slideLayoutDirection === "Horizontal" ? "row" : "auto";
+  const chartHint = designHint("chartPrimary")?.value ?? (typeof layout.contentTypeChartPrimary === "string" ? layout.contentTypeChartPrimary.toLowerCase() : void 0);
+  const chartSide = chartHint === "left" || chartHint === "right" || chartHint === "top" || chartHint === "bottom" ? chartHint : void 0;
+  const chartIndex = pending.findIndex((node) => !node.children && node.field === "chart");
+  const chartPrimary = chartSide !== void 0 && !ownMode && !regions.length && chartIndex >= 0 && pending.some((node) => node.children || node.field !== "chart") ? chartSide : void 0;
+  const rootSettings = chartPrimary ? { ...composition, mode: chartPrimary === "left" || chartPrimary === "right" ? "row" : "column", columns: void 0, weights: chartPrimary === "left" || chartPrimary === "top" ? [3, 2] : [2, 3] } : { ...composition, mode: composition.mode ?? directionMode ?? layoutDirectionMode };
+  if (chartPrimary) {
+    const primary = pending[chartIndex], rest = pending.filter((_, index) => index !== chartIndex);
+    const container = { field: "blocks", type: "group", value: rest.map((node) => node.payload), path, payload: {}, children: rest, composition: {}, synthetic: true };
+    arrange(chartPrimary === "left" || chartPrimary === "top" ? [primary, container] : [container, primary], contentBox, rootSettings, 0);
+  } else arrange(pending, contentBox, rootSettings, composition.mode ? 0 : placeholders.length);
+  if (listBullet?.value === "image" && !bulletImage && items.some((item) => (item.field === "items" || item.field === "bullets") && item.payload.numbering === void 0)) {
+    diagnostics.push({ code: "unresolved-content", path: listBullet.path, message: "Picture bullets (listBullet: image) need design.logo or a primary organization logo; the marker glyph is drawn instead." });
+  }
+  const numberingDiagnostics = [];
+  for (const item of items) {
+    for (const key of ["x", "y", "width", "height"]) item.box[key] = round2(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 entry of item.text?.listEntries ?? []) {
+      if (entry.marker.number?.adapted) numberingDiagnostics.push({ code: "numbering-adapted", path: entry.textPath ?? item.path, message: `Roman numerals stop at 3999; this entry is numbered ${entry.marker.number.value} in arabic, as PowerPoint draws it.` });
+    }
+  }
+  for (const group of groups) for (const box of [group.box, group.contentBox]) for (const key of ["x", "y", "width", "height"]) box[key] = round2(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, ...numberingDiagnostics);
+  return { width, height, contentBox, items, groups, flows, diagnostics, composition, ...furniture ? { furniture } : {}, ...slideImage ? { slideImage } : {}, ...logo ? { logo } : {}, ...rtl ? { direction: "rtl" } : {}, ...footnotes ? { footnotes } : {}, ...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 = record4(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 { CAPTIONABLE_FIELDS, CAPTION_FONT_RATIO, CAPTION_MAX_RATIO, CHART_SERIES_MIN_DIFFERENCE, CHART_SERIES_MIN_LIGHTNESS_STEP, CITATION_MARKER_RAISE, CITATION_MARKER_SCALE, DEFAULT_CHART_LABEL_SEPARATOR, DEFAULT_FONT_SCHEME, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_SLIDE_NUMBER_FORMAT, FONT_SIZE_GRID_PER_PX, FOOTNOTE_MAX_RATIO, MAX_COMPOSITION_DEPTH, MAX_NUMBERING_LEVELS, MAX_NUMBERING_VALUE, MAX_ROMAN_VALUE, NUMBERING_STYLES, NUMBERING_SUFFIXES, OPFCompositionError, PICTURE_BULLET_SCALE, annotationText, bareIdPattern, captionSettings, catalogIds, chartColorForFill, chartLabelText, chartOptionSupport, chartOptionTarget, chartPaletteForFill, citationMarkerText, collectCitations, colorContrast, composeSlide, deprecatedCatalogIds, fitList, fitRichText, fitText, formatChartLabelNumber, formatChartLabelPercent, formatFurnitureDate, formatListNumber, formatSlideNumber, intrinsicImageSize, isRecord2 as isRecord, layoutCaption, layoutCode, layoutFootnotes, layoutFurniture, layoutMetric, layoutQuote, layoutTable, layoutTimeline, listNumbers, measureText, measureTextOutline, normalizeHexColor, numberingAtLevel, numberingFindings, numberingStyleDraws, paragraphDirection, paragraphDirectionAt, parseIsoDate, pathFor, physicalAlignment, placeTextLines, promotedRegionKeys, readingRows, referencesSlide, resolveCanvasDimensions, resolveChartOptions, resolveColorRef, resolveFontFamilies, resolveFontSchemeReference, resolveLogo, resolveNumbering, resolveScriptFonts, resolveSlideDirection, resolveSocialProfile, resolveTextStyle, scriptFontRole, sliceNumberedItems, slideCitations, slideImageShape, snapFontSizeDown, snapFontSizeUp, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, visitContentPayloads, visualReadingOrder, walkCitationRuns, wrapText };