@openpresentation/opf 0.11.4 → 0.12.1

package/dist/{chunk-3H2U7FDR.js → chunk-HOBSL7AJ.js}

@@ -1,3 +1,5 @@
+import { catalogs } from './chunk-E34DJ5LL.js';
+
 // src/table.ts
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 function tableGrid(value, path = "table") {
@@ -49,8 +51,8 @@ function dataBytes(uri, limit) {
   const type = (match[1] ?? "").toLowerCase(), start = match[0].length;
   try {
     if (/;base64/i.test(match[2] ?? "")) {
-      const chars = Math.ceil(limit / 3) * 4, text = uri.slice(start, start + chars + chars / 8).replace(/\s+/g, "").slice(0, chars);
-      return { type, bytes: Uint8Array.from(atob(text.slice(0, text.length - text.length % 4)), (char) => char.charCodeAt(0)) };
+      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)) };
@@ -99,8 +101,8 @@ function rasterDimensions(b) {
   }
   return void 0;
 }
-function svgDimensions(text) {
-  const root = /<svg\b([^>]*)>/i.exec(text)?.[1];
+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) => {
@@ -118,7 +120,7 @@ function svgDimensions(text) {
 }
 var cache = /* @__PURE__ */ new Map();
 var CACHE_ENTRIES = 64;
-function readAspect(source) {
+function readDimensions(source) {
   const first = dataBytes(source, PREFIX_BYTES);
   if (!first) return void 0;
   let dimensions;
@@ -130,17 +132,540 @@ function readAspect(source) {
       if (more) dimensions = rasterDimensions(more.bytes);
     }
   }
-  return dimensions && dimensions.width > 0 && dimensions.height > 0 ? dimensions.width / dimensions.height : void 0;
+  return dimensions && dimensions.width > 0 && dimensions.height > 0 ? dimensions : void 0;
 }
-function intrinsicImageAspect(value, assets) {
+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)) return cache.get(source);
-  const aspect = readAspect(source);
-  if (cache.size >= CACHE_ENTRIES) cache.delete(cache.keys().next().value);
-  cache.set(source, aspect);
-  return aspect;
+  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
@@ -152,10 +677,10 @@ var tokenWidths = { y: [1, 2, 4], M: [1, 2, 3, 4], d: [1, 2], E: [1, 2, 3, 4] };
 function parseFurnitureDateFormat(pattern) {
   if (!pattern) return "dateFormat must not be empty.";
   const tokens = [];
-  const literal = (text) => {
+  const literal = (text2) => {
     const last = tokens[tokens.length - 1];
-    if (last?.kind === "literal") last.text += text;
-    else tokens.push({ kind: "literal", text });
+    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);
@@ -165,21 +690,21 @@ function parseFurnitureDateFormat(pattern) {
         index += 2;
         continue;
       }
-      let end = index + 1, text = "";
+      let end = index + 1, text2 = "";
       for (; ; ) {
         if (end >= pattern.length) return "dateFormat has an unterminated quoted literal.";
         if (pattern[end] === "'") {
           if (pattern[end + 1] === "'") {
-            text += "'";
+            text2 += "'";
             end += 2;
             continue;
           }
           break;
         }
-        text += pattern[end];
+        text2 += pattern[end];
         end++;
       }
-      literal(text);
+      literal(text2);
       index = end + 1;
       continue;
     }
@@ -214,39 +739,39 @@ function formatFurnitureDate(iso, pattern) {
   const utc = new Date(Date.UTC(2e3, date.month - 1, date.day));
   utc.setUTCFullYear(date.year);
   const pad = (value, width) => String(value).padStart(width, "0");
-  let text = "";
+  let text2 = "";
   for (const token of tokens) {
     if (token.kind === "literal") {
-      text += token.text;
+      text2 += token.text;
       continue;
     }
     const { letter, width } = token;
-    if (letter === "y") text += width === 2 ? pad(date.year % 100, 2) : width === 4 ? pad(date.year, 4) : String(date.year);
+    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] ?? "";
-      text += width >= 3 ? width === 4 ? name : name.slice(0, 3) : pad(date.month, width);
-    } else if (letter === "d") text += pad(date.day, width);
+      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()] ?? "";
-      text += width === 4 ? name : name.slice(0, 3);
+      text2 += width === 4 ? name : name.slice(0, 3);
     }
   }
-  return { text };
+  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 text = "";
+  let text2 = "";
   const fields2 = [];
   for (const piece of format.split(/(\{current\}|\{total\})/)) {
     if (piece === "{current}") {
       const value = String(current);
-      fields2.push({ type: "slideNumber", start: text.length, end: text.length + value.length });
-      text += value;
-    } else if (piece === "{total}") text += String(total);
-    else text += piece;
+      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, fields: fields2 };
+  return { text: text2, fields: fields2 };
 }
 
 // src/color.ts
@@ -358,6 +883,988 @@ function chartColorForFill(fill, preferred) {
   }
   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 = {
+  "audiences/executives": "executive",
+  "audiences/investors": "investor",
+  "audiences/customers": "customer",
+  "audiences/sales-team": "sales",
+  "audiences/marketing-team": "marketing",
+  "audiences/regulators": "regulatory",
+  "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;
@@ -368,14 +1875,14 @@ function resolveFontSchemeReference(reference, lookup, path = "design.fontScheme
   const overrides = typeof reference === "object" && reference !== null && !Array.isArray(reference) ? reference : void 0;
   const id = typeof reference === "string" ? reference : typeof overrides?.id === "string" ? overrides.id : void 0;
   const found = id === void 0 ? void 0 : lookup(id);
-  const base = record2(found ?? lookup(DEFAULT_FONT_SCHEME));
+  const 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 = record2(input);
-  const family = (value) => typeof value === "string" ? value : record2(value).family;
+  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,
@@ -389,27 +1896,28 @@ function resolveTextStyle(style, measurement) {
 }
 function textWidthMeasurer(style, measurement) {
   if (!measurement) return measureText;
-  return (text, size) => {
-    const width = measurement.measure(text, size, style);
+  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(text, fontSize, style, measurement) {
+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(text, fontSize, style);
+  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) {
+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 factor = alignment === "right" ? 1 : alignment === "center" ? 0.5 : 0, placed = [];
+  const placed = [];
   let shift = 0, bottom = box.y, height = 0, overflow = false;
-  for (const line of lines) {
+  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.");
@@ -425,7 +1933,7 @@ function placeTextLines(lines, box, alignment = "left", rasterPadding = 0) {
     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 });
+    placed.push({ x, y, baseline, height: line.height, width: line.width, outline, ...directions ? { alignment: lineAlignment } : {} });
   }
   return { alignment, rasterPadding, lines: placed, height, overflow };
 }
@@ -460,14 +1968,14 @@ var headings = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
 var COVER_LAYOUT_IDS = /* @__PURE__ */ new Set(["title", "title-subtitle"]);
 var rows = ["top", "middle", "bottom"];
 var columns = ["left", "center", "right"];
-var record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var record4 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 var kind = (field) => field === "items" ? "list" : field === "bullets" ? "text" : field;
-var round = (value) => Math.round(value * 1e6) / 1e6 || value;
+var 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 : record2(value).src;
+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(round(value));
+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;
@@ -488,15 +1996,17 @@ function slideImageShape(kind2, box, cornerRadius = 1 / 6) {
   }
   return { kind: "rectangle", preset: "rect", adjust: {}, path: rect };
 }
-function resolveSlideImage(slide, layout, presentation, width, height, path, padding, scale, diagnostics) {
-  const own = record2(slide.design), deck = record2(record2(presentation).design);
+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 ? record2(configured) : 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 position = treatment ? treatment.position : SLIDE_IMAGE_POSITIONS.find((value2) => value2 === alignment) ?? "background";
-  if (!SLIDE_IMAGE_POSITIONS.includes(position)) return 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;
@@ -507,8 +2017,8 @@ function resolveSlideImage(slide, layout, presentation, width, height, path, pad
   const t = treatment ?? {};
   const fill = t.fill === "crop" || t.fill === "fit" ? t.fill : (own.imageFill ?? deck.imageFill) === "fit" ? "fit" : "crop";
   const share = finite(t.size, 0.1, 0.9) ?? SLIDE_IMAGE_BAND;
-  const band = { width: round(width * share), height: round(height * share) };
-  const region = position === "left" ? { x: 0, y: 0, width: band.width, height } : position === "right" ? { x: round(width - band.width), y: 0, width: band.width, height } : position === "top" ? { x: 0, y: 0, width, height: band.height } : position === "bottom" ? { x: 0, y: round(height - band.height), width, height: band.height } : { x: 0, y: 0, width, height };
+  const 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 };
@@ -517,7 +2027,7 @@ function resolveSlideImage(slide, layout, presentation, width, height, path, pad
     const frameWidth = Math.min(box.width, box.height * aspect), frameHeight = frameWidth / aspect;
     box = { x: box.x + (box.width - frameWidth) / 2, y: box.y + (box.height - frameHeight) / 2, width: frameWidth, height: frameHeight };
   }
-  box = { x: round(box.x), y: round(box.y), width: round(box.width), height: round(box.height) };
+  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,
@@ -530,19 +2040,19 @@ function resolveSlideImage(slide, layout, presentation, width, height, path, pad
     shape: slideImageShape(kind2, box, finite(t.cornerRadius, 0, 0.5))
   };
   if (typeof t.alt === "string") result.alt = t.alt;
-  const border = record2(t.border), borderWidth = finite(border.width, 0, 64);
-  if (border.color !== void 0 && borderWidth) result.border = { color: border.color, width: round(borderWidth * scale) };
+  const 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 (record2(t.recolor).dark !== void 0 && record2(t.recolor).light !== void 0) result.recolor = { type: "duotone", dark: t.recolor.dark, light: t.recolor.light };
-  const overlay = record2(t.overlay), overlayOpacity = finite(overlay.opacity, 0, 1);
+  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) ? overlay.edge : 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: round(box.height * part) } : edge === "bottom" ? { ...box, y: round(box.y + box.height * (1 - part)), height: round(box.height * part) } : edge === "left" ? { ...box, width: round(box.width * part) } : { ...box, x: round(box.x + box.width * (1 - part)), width: round(box.width * part) };
+      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 };
     }
   }
@@ -565,10 +2075,10 @@ function resolveLogo(presentation, slide, options = {}) {
   };
   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 record2(value)) {
+    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 = record2(value);
+    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];
@@ -576,16 +2086,16 @@ function resolveLogo(presentation, slide, options = {}) {
     }
     return null;
   };
-  const deck = record2(presentation), slideIndex = Number.isSafeInteger(options.slideIndex) && options.slideIndex >= 0 ? options.slideIndex : 0;
-  const own = pick(record2(record2(slide).design).logo, `slides.${slideIndex}.design.logo`);
+  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(record2(deck.design).logo, "design.logo");
+  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) => record2(item).role === "primary");
+  const primaryIndex = organizations.findIndex((item) => record4(item).role === "primary");
   const index = primaryIndex >= 0 ? primaryIndex : organizations.findIndex(Boolean);
   if (index < 0) return null;
-  return pick(record2(organizations[index]).logo, Array.isArray(deck.organization) ? `organization.${index}.logo` : "organization.logo");
+  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") {
@@ -603,10 +2113,11 @@ function resolveSocialProfile(platform, value, records = [], owner = "organizati
   return { text: display(url), href: encodeURI(url), resolved: true };
 }
 function layoutFurniture(input, options = {}) {
-  const slide = record2(input), width = options.width ?? 1280, height = options.height ?? 720, scale = Math.min(width, height) / 720;
-  const settings = { ...record2(record2(options.layout).composition), ...record2(slide.composition) };
+  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 minimum = (settings.minFontSize ?? 16) * scale, size = Math.max(13 * scale, minimum), padding = (options.textRasterPadding ?? 2) * scale;
+  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.");
@@ -615,32 +2126,33 @@ function layoutFurniture(input, options = {}) {
   if (options.date !== void 0 && (typeof options.date !== "string" || !parseIsoDate(options.date))) throw new RangeError("The furniture date option must be an ISO YYYY-MM-DD calendar date.");
   const outlines = options.textMeasurement?.outlineBounds !== void 0, parts = [], diagnostics = [];
   const sourceRoot = `slides.${options.slideIndex ?? 0}`, organizations = Array.isArray(options.presentation?.organization) ? options.presentation.organization : [options.presentation?.organization];
-  const primaryIndex = organizations.findIndex((item) => record2(item).role === "primary"), organizationIndex = primaryIndex >= 0 ? primaryIndex : organizations.findIndex(Boolean);
-  const organization = record2(organizations[organizationIndex]), organizationRoot = Array.isArray(options.presentation?.organization) ? `organization.${organizationIndex}` : "organization", organizationPath = `${organizationRoot}.name`;
-  const inlinePlatforms = record2(record2(options.presentation?.catalogs).socialPlatforms).records, platformRecords = [...Array.isArray(inlinePlatforms) ? inlinePlatforms : [], ...options.socialPlatforms ?? []];
+  const 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 = record2(slide.design)[kind2] !== void 0, value = local ? record2(slide.design)[kind2] : options.presentation?.design?.[kind2];
+    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 content = record2(record2(value)[zone]), path = `${root}.${zone}`, x = width * (0.07 + index * 0.3), zoneWidth = width * 0.26, zoneParts = [];
+      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, text, generated = false, sourcePath, extras = {}) => {
-        if (text === void 0) return;
-        if (typeof text !== "string") throw new TypeError(`Furniture field ${path}.${field} requires string content.`);
+      const 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(text, { width: Math.max(Number.MIN_VALUE, zoneWidth - (outlines ? 2 * padding : 0)), height: Number.MAX_VALUE }, size, size, textWidthMeasurer(style, 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(text.slice(segment.start, segment.end), size, style, options.textMeasurement);
+              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;
@@ -656,30 +2168,30 @@ function layoutFurniture(input, options = {}) {
           }
           return { width: line.width, y: index2 * fit.lineHeight, baseline: size + index2 * fit.lineHeight, height: fit.lineHeight, outline };
         });
-        const natural = outlines ? placeTextLines(ink, { x, y, width: zoneWidth, height: Number.MAX_VALUE }, zone, padding) : void 0;
+        const 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, zone, padding) : void 0;
+        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, style, requestedFontSize: 13 * scale, minFontSize: minimum, box, alignment: zone, fit: accepted, ...extras.fields?.length ? { fields: extras.fields } : {}, ...extras.links?.length ? { links: extras.links } : {} });
+        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, record2(options.presentation).assets) ?? 1));
-        return { x: zone === "left" ? x : zone === "center" ? x + (zoneWidth - imageWidth) / 2 : x + zoneWidth - imageWidth, y, width: imageWidth, height: imageHeight };
+        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: zone });
+          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: zone });
+        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);
@@ -688,7 +2200,7 @@ function layoutFurniture(input, options = {}) {
         else error(`${path}.organization`, "Generated organization name needs a named organization in the presentation.", "unresolved-content");
       }
       if (content.socials === true) {
-        const links = Object.entries(record2(organization.socials)).filter(([, value2]) => typeof value2 === "string" && value2.trim()).map(([platform, value2]) => ({ platform, sourcePath: `${organizationRoot}.socials.${platform}`, ...resolveSocialProfile(platform, value2, platformRecords, "organization") }));
+        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");
       }
@@ -740,29 +2252,43 @@ function layoutFurniture(input, options = {}) {
   return { algorithm: "furniture-flow-v2", configured, textMeasurement: options.textMeasurement ? "provided" : "estimated", textOutlines: outlines ? "provided" : "unavailable", parts, headerBottom, footerTop, diagnostics, overflow: diagnostics.length > 0 };
 }
 var textSegments = new Intl.Segmenter("und", { granularity: "grapheme" });
-function measureText(text, fontSize) {
+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 text) {
+  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(text, width, fontSize, measure = measureText) {
-  return fitSourceText(text, { width, height: Number.MAX_VALUE }, fontSize, fontSize, 1, measure, true).lines;
+function wrapText(text2, width, fontSize, measure = measureText) {
+  return fitSourceText(text2, { width, height: Number.MAX_VALUE }, fontSize, fontSize, 1, measure, true, false).lines;
 }
-function fitText(text, box, requestedSize = 25, minFontSize = 16, measure = measureText) {
+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(text, box, Math.max(requestedSize, minFontSize), minFontSize, 1, measure, true);
+  return fitSourceText(text2, box, Math.max(requestedSize, minFontSize), minFontSize, 1, measure, true, true, direction);
 }
-function fitAtSizes(layout, requested, minimum, step = 1) {
+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 size = trial === 64 ? minimum : Math.max(minimum, start - trial * step), result = layout(size);
-    if (!result.overflow || size === minimum) return result;
+    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.");
 }
@@ -772,7 +2298,7 @@ function layoutQuote(value, box, options = {}) {
   if (!quote || Array.isArray(quote) || typeof quote.text !== "string" || [quote.attribution, quote.source].some((field) => field !== void 0 && typeof field !== "string")) {
     throw new TypeError("Quote content must be a string or a text object with optional string attribution/source.");
   }
-  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale;
+  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.");
   }
@@ -780,23 +2306,23 @@ function layoutQuote(value, box, options = {}) {
   const path = options.path ?? "quote";
   const diagnostics = [], parts = [];
   const report = (reason, diagnosticPath, roles, message) => diagnostics.push({ code: "text-overflow", reason, path: diagnosticPath, parts: roles, message });
-  const source = (sourcePath, text, outputStart) => ({ path: sourcePath, start: 0, end: text.length, outputStart, outputEnd: outputStart + text.length });
-  const add = (role, text, sources, area, fontSize, fontFamily, fontWeight, partPath) => {
+  const 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 = Math.max(fontSize * scale, minimum);
-    const part = { role, path: partPath, text, sources, box: area, requestedFontSize, minFontSize: minimum, requestedStyle, style };
+    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 text = quote[field];
-    if (!text) continue;
+    const text2 = quote[field];
+    if (!text2) continue;
     if (footer) footer += " - ";
-    footerSources.push(source(`${path}.${field}`, text, footer.length));
-    footer += text;
+    footerSources.push(source(`${path}.${field}`, text2, footer.length));
+    footer += text2;
   }
   const bodyPath = shorthand ? path : `${path}.text`;
   const body = add(
@@ -820,7 +2346,7 @@ function layoutQuote(value, box, options = {}) {
     path
   ) : void 0;
   const usable = (area) => [area.x, area.y, area.width, area.height].every(Number.isFinite) && area.width > 0 && area.height > 0;
-  const fit = (part, area, size = part.requestedFontSize, floor = minimum) => usable(area) ? fitText(part.text, area, size, floor, textWidthMeasurer(part.style, options.textMeasurement)) : void 0;
+  const 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) {
@@ -877,31 +2403,31 @@ function layoutMetric(value, box, options = {}) {
   if (!metric || Array.isArray(metric) || !isValue(metric.value) || [metric.label, metric.description, metric.unit].some((field) => field !== void 0 && typeof field !== "string") || metric.delta !== void 0 && !isValue(metric.delta) || metric.trend !== void 0 && !["up", "down", "flat"].includes(metric.trend)) {
     throw new TypeError("Metric content requires a finite numeric or string value and schema-valid display metadata.");
   }
-  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale;
+  const 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 alignment = options.align ?? "left";
-  if (!["left", "center", "right"].includes(alignment)) throw new RangeError("Invalid metric alignment.");
+  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 text = String(sourceValue), path = scalar ? sourcePath : `${sourcePath}.${role}`;
+    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,
-      sources: [{ path, value: sourceValue, start: 0, end: text.length }],
-      visible: role === "value" || text.length > 0,
+      text: text2,
+      sources: [{ path, value: sourceValue, start: 0, end: text2.length }],
+      visible: role === "value" || text2.length > 0,
       linePositions: [],
       box: { ...box, height: 0 },
-      requestedFontSize: Math.max(nominal, minimum),
+      requestedFontSize: gridFontSize(nominal, minimum),
       minFontSize: minimum,
       requestedStyle,
       style: resolveTextStyle({ ...requestedStyle }, options.textMeasurement)
@@ -910,6 +2436,8 @@ function layoutMetric(value, box, options = {}) {
     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;
@@ -946,7 +2474,7 @@ function layoutMetric(value, box, options = {}) {
     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));
+      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);
@@ -956,7 +2484,7 @@ function layoutMetric(value, box, options = {}) {
   const fitValue = (area, singleLine) => {
     if (!usable(area)) return void 0;
     for (let step = 0; step <= 76; step++) {
-      const size = Math.max(minimum, primary.requestedFontSize - step * scale);
+      const 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;
@@ -965,7 +2493,7 @@ function layoutMetric(value, box, options = {}) {
   let selected, attempts = 0;
   const reductions = Math.min(23, Math.ceil(Math.max(0, ...metadata.map((part) => (part.requestedFontSize - minimum) / scale))));
   for (let reduction = 0; reduction <= reductions; reduction++) {
-    const measured = new Map(metadata.map((part) => [part, measure(part, Math.max(minimum, part.requestedFontSize - reduction * scale), box.width)]));
+    const 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;
@@ -1043,17 +2571,17 @@ function layoutTimeline(value, box, options = {}) {
   if (!timeline || !Array.isArray(timeline.events) || !timeline.events.length || [timeline.name, timeline.description].some((field) => field !== void 0 && typeof field !== "string") || timeline.events.some((event) => !event || typeof event.what !== "string" || [event.when, event.description].some((field) => field !== void 0 && typeof field !== "string"))) {
     throw new TypeError("Timeline content requires ordered events with string labels and optional string metadata.");
   }
-  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale, padding = (options.textRasterPadding ?? 1) * scale;
+  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;
+  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, text, partPath, size, weight, eventIndex) => {
-    if (text === void 0) return;
+  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, sources: [{ path: partPath, start: 0, end: text.length }], box: { ...box }, alignment: "center", requestedFontSize: Math.max(size * scale, minimum), minFontSize: minimum, requestedStyle, style: resolveTextStyle({ ...requestedStyle }, options.textMeasurement) });
+    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);
@@ -1070,7 +2598,7 @@ function layoutTimeline(value, box, options = {}) {
     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));
+    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) {
@@ -1087,7 +2615,7 @@ function layoutTimeline(value, box, options = {}) {
       }
       return { width: line.width, y: index * fit.lineHeight, baseline: size + index * fit.lineHeight, height: fit.lineHeight, outline: hasInk ? { x: left, y: top, width: right - left, height: bottom - top } : null };
     });
-    const placement = outlines ? placeTextLines(ink, { x: 0, y: 0, width, height: Number.MAX_VALUE }, alignment, padding) : void 0;
+    const 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 };
@@ -1108,8 +2636,8 @@ function layoutTimeline(value, box, options = {}) {
         score2 += Math.max(1, excess);
       };
       const place = (part, x, y2, width, alignment) => {
-        const measured = measure(part, Math.max(minimum, part.requestedFontSize - reduction * scale), Math.max(scale, width), alignment);
-        const area = { x, y: y2, width: Math.max(scale, width), height: Math.max(scale, measured.height) }, placement = outlines ? placeTextLines(measured.ink, area, alignment, padding) : void 0;
+        const 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);
@@ -1127,7 +2655,7 @@ function layoutTimeline(value, box, options = {}) {
         const width = box.width / Math.max(2, count), step = (box.width - width) / Math.max(1, count - 1), start = count === 1 ? box.x + box.width / 2 : box.x + width / 2;
         const lineY = y + Math.max(scale, available) * 0.46;
         events.forEach((fields2, index) => {
-          const x = start + index * step, top = index % 2 === 0 ? y : lineY + 24 * scale, bottom = index % 2 === 0 ? lineY - 24 * scale : box.y + box.height;
+          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) {
@@ -1137,7 +2665,7 @@ function layoutTimeline(value, box, options = {}) {
           }
         });
       } else {
-        const x = box.x + radius, textX = box.x + 24 * scale, width = box.width - 24 * scale;
+        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;
@@ -1154,7 +2682,7 @@ function layoutTimeline(value, box, options = {}) {
         diagnostics.push({ code: "text-overflow", reason: "event-space", path: marker.path, message: "Timeline marker has no usable space; increase the cell or paginate events." });
         score2 += 1;
       }
-      const first = markers[0], last = markers.at(-1), connector = { x1: first.x, y1: first.y, x2: last.x, y2: last.y };
+      const 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;
@@ -1165,26 +2693,27 @@ function layoutTimeline(value, box, options = {}) {
   if (result.diagnostics.length && options.overflow === "error") throw new OPFCompositionError(result.diagnostics);
   return { algorithm: "timeline-flow-v1", attempts, textMeasurement: options.textMeasurement ? "provided" : "estimated", textOutlines: outlines ? "provided" : "unavailable", ...result, overflow: result.diagnostics.length > 0 };
 }
-function fitCodeText(text, box, size, minimum, step, measure) {
-  return fitSourceText(text, box, size, minimum, step, measure);
+function fitCodeText(text2, box, size, minimum, step, measure, direction) {
+  return fitSourceText(text2, box, size, minimum, step, measure, false, true, direction);
 }
-function fitSourceText(text, box, size, minimum, step, measure, prose = false) {
+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) || text.includes("	") && tabWidth <= 0) throw new RangeError("Text tabs require a positive finite measured space advance.");
-    const measureLine = (start2, end2, record3 = false) => {
+    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 text.slice(start2, end2).split("	").entries()) {
+      for (const [index, segment] of text2.slice(start2, end2).split("	").entries()) {
         if (index) {
           const next = (Math.floor(x / tabWidth + 1e-9) + 1) * tabWidth;
-          if (record3) segments.push({ kind: "tab", start: offset, end: offset + 1, x, width: next - x });
+          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 (record3) segments.push({ kind: "text", start: offset, end: offset + segment.length, x, width: advance });
+          if (record5) segments.push({ kind: "text", start: offset, end: offset + segment.length, x, width: advance });
           x += advance;
           offset += segment.length;
         }
@@ -1193,26 +2722,34 @@ function fitSourceText(text, box, size, minimum, step, measure, prose = false) {
     };
     const width = (start2, end2) => measureLine(start2, end2).width;
     const sourceLines = [];
-    let start = 0, end = 0;
+    let start = 0, end = 0, hangFrom = -1;
     const push = (last, nextStart, boundary) => {
-      sourceLines.push({ start, end: last, nextStart, boundary, ...measureLine(start, last, true) });
+      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 text.matchAll(tokens)) {
+    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 + 0.01) {
+      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(text.slice(start, end))) push(a, a, "soft");
-      if (width(start, b) <= box.width + 0.01) {
+      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;
       }
@@ -1229,39 +2766,40 @@ function fitSourceText(text, box, size, minimum, step, measure, prose = false) {
     push(end, end, "end");
     const lineHeight = fontSize * 1.22;
     return {
-      lines: sourceLines.map((line) => text.slice(line.start, line.end)),
+      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);
+  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 = (options.minFontSize ?? 16) * scale;
+  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, text, partPath, generated = false) => {
+  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,
-      sources: generated ? [] : [{ path: partPath, start: 0, end: text.length }],
+      text: text2,
+      sources: generated ? [] : [{ path: partPath, start: 0, end: text2.length }],
       generated,
       box: { ...inner },
-      requestedFontSize: Math.max((role === "body" ? 18 : 14) * scale, minimum),
+      requestedFontSize: gridFontSize((role === "body" ? 18 : 14) * scale, minimum),
       minFontSize: minimum,
       requestedStyle,
       style: resolveTextStyle({ ...requestedStyle }, options.textMeasurement)
@@ -1318,7 +2856,7 @@ function layoutCode(value, box, options = {}) {
 }
 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);
+  const layout = richTextLayouter(input, box, requestedSize, options, minFontSize);
   return fitAtSizes(layout, requestedSize, richMinimum(input, requestedSize, minFontSize));
 }
 function richMinimum(input, requested, minimum) {
@@ -1332,7 +2870,7 @@ function richMinimum(input, requested, minimum) {
   }
   return visible ? floor : minimum;
 }
-function richTextLayouter(input, box, requestedSize, options) {
+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;
@@ -1340,23 +2878,26 @@ function richTextLayouter(input, box, requestedSize, options) {
     const start = offset;
     offset += run.text.length;
     const style = resolveTextStyle({ ...options.style, fontFamily: run.fontFamily ?? options.style.fontFamily, fontWeight: run.bold === void 0 ? options.style.fontWeight : run.bold ? 700 : 400, italic: run.italic ?? options.style.italic, path: options.style.path ? `${options.style.path}.${runIndex}` : void 0 }, options.textMeasurement);
-    return { run, runIndex, start, end: offset, style };
+    const 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 layout = (fontSize) => {
-    const ratio = fontSize / requestedSize;
+  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 text = whole.slice(a, b), normalSize = (entry.run.fontSize !== void 0 ? entry.run.fontSize * 4 / 3 : requestedSize) * ratio;
+        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 = normalSize * (script ? 0.7 : 1), baselineShift = entry.run.superscript ? -normalSize * 0.35 : entry.run.subscript ? normalSize * 0.2 : 0;
+        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 text.split("	").entries()) {
+        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.");
@@ -1372,13 +2913,20 @@ function richTextLayouter(input, box, requestedSize, options) {
             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 = [];
-    let lineStart = 0, lineEnd = 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;
@@ -1391,26 +2939,32 @@ function richTextLayouter(input, box, requestedSize, options) {
         lineEnd = end;
         continue;
       }
-      if (width(lineStart, end) <= box.width) {
+      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) {
+      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) push(start + index);
+        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) => {
-      const parts = fragments(range.start, range.end), ascent = Math.max(fontSize, ...parts.map((part) => part.fontSize - part.baselineShift)), descent = Math.max(fontSize * 0.22, ...parts.map((part) => part.fontSize * 0.22 + part.baselineShift));
-      const height = ascent + descent, line = { fragments: parts, width: parts.reduce((sum, p) => sum + p.width, 0), y, baseline: y + ascent, height };
+    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;
     });
@@ -1424,7 +2978,15 @@ function richTextLayouter(input, box, requestedSize, options) {
         y += height;
       }
     }
-    return { lines: ranges.map((range) => whole.slice(range.start, range.end)), fontSize, lineHeight: Math.max(fontSize * 1.22, ...richLines.map((line) => line.height)), richLines, height: y, overflow: y > box.height + 0.01 || richLines.some((line) => line.width > box.width + 0.01) };
+    return {
+      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;
 }
@@ -1433,36 +2995,50 @@ function fitList(input, box, requestedSize = 25, minFontSize = 16, options = { s
   if (!Array.isArray(input) || ![box.width, box.height, requestedSize, minFontSize].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("List content, dimensions and font sizes must be valid.");
   const source = input.map((value, index) => {
     const object = typeof value === "object" && !Array.isArray(value) ? value : void 0;
-    const text = object ? object.text : value, description = object?.description, level = object?.level ?? 0;
+    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(text)) || description !== void 0 && !Array.isArray(runs(description))) throw new TypeError("List text and descriptions must be strings or text runs.");
+    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;
-    return { index, level, value: text, descriptionValue: description, textPath: base ? base + (object ? ".text" : "") : void 0, descriptionPath: base ? base + ".description" : void 0, runs: runs(text), descriptionRuns: description === void 0 ? void 0 : runs(description) };
+    const 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 = [];
+    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 indent = fontSize * 1.1, offset = Math.min(box.width, item.level * indent), x = box.x + offset + indent, width = Math.max(1, box.x + box.width - x);
+      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 text = richTextLayouter(item.runs, textBox, requestedSize, { ...options, style })(fontSize);
-      textBox.height = text.height;
-      lines.push(...text.lines);
-      y += text.height;
+      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 } })(fontSize * 0.82);
+        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 ||= text.overflow || !!description?.overflow;
-      const marker = { text: ["\u2022", "\u25E6", "\u25AA"][item.level % 3], x: box.x + offset, y: textBox.y + (text.richLines[0]?.baseline ?? fontSize), fontSize, style: resolveTextStyle(style, options.textMeasurement), indent }, side = fontSize * PICTURE_BULLET_SCALE;
+      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,
@@ -1470,17 +3046,18 @@ function fitList(input, box, requestedSize = 25, minFontSize = 16, options = { s
         descriptionValue: item.descriptionValue,
         textPath: item.textPath,
         descriptionPath: item.descriptionPath,
-        text,
+        text: text2,
         textBox,
         description,
         descriptionBox,
         marker,
-        ...options.bulletImage ? { bulletImage: options.bulletImage, bulletBox: { x: marker.x, y: marker.y - side, width: side, height: side } } : {}
+        ...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 };
+    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) {
@@ -1492,16 +3069,16 @@ function fitList(input, box, requestedSize = 25, minFontSize = 16, options = { s
 function contentText(field, value) {
   if (field === "text" || headings.has(field)) return flatten(value);
   if (field === "items" || field === "bullets") return (Array.isArray(value) ? value : [value]).map((item) => {
-    const entry = record2(item);
+    const entry = record4(item);
     return `\u2022 ${flatten(item)}${entry.description ? `
 ${flatten(entry.description)}` : ""}`;
   }).join("\n");
-  if (field === "code") return flatten(record2(value).source ?? value);
-  if (field === "quote") return flatten(record2(value).text ?? value);
+  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 = (options.minFontSize ?? 16) * scale, requested = Math.max(15 * scale, minimum);
+  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}`);
@@ -1515,13 +3092,13 @@ function layoutTable(value, box, options = {}) {
   const cellMinimum = (cell) => Array.isArray(cell.value) ? richMinimum(cell.value, requested, minimum) : minimum;
   const fitCell = (cell, height, min) => {
     const textBox = { width: Math.max(scale, cell.width), height: Math.max(scale, height) };
-    return Array.isArray(cell.value) ? fitRichText(cell.value, textBox, requested, min, { style: cell.textStyle, textMeasurement: options.textMeasurement, uniformLineHeight: true }) : fitText(flatten(cell.value), textBox, requested, min, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement));
+    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 = natural2 ? Math.max(requested, floor) : floor;
+    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 })(size) : fitText(flatten(cell.value), textBox, size, size, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement));
+    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);
@@ -1544,13 +3121,13 @@ function layoutTable(value, box, options = {}) {
   let overflow = false;
   const rows2 = heights.map((height, r) => ({ box: { x: box.x, y: ys[r], width: box.width, height }, cells: [] }));
   for (const cell of cells) {
-    const cellBox = { x: box.x + cell.column * cellWidth, y: ys[cell.row], width: cell.colSpan * cellWidth, height: ys[cell.row + cell.rowSpan] - ys[cell.row] };
+    const 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 });
+    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 };
 }
@@ -1561,7 +3138,7 @@ function flatten(value) {
   if (value == null) return "";
   if (typeof value !== "object") return String(value);
   if (Array.isArray(value)) return value.map(flatten).join("");
-  const item = record2(value);
+  const item = record4(value);
   return flatten(item.text ?? item.value ?? item.source ?? JSON.stringify(value));
 }
 function regionParts(key) {
@@ -1617,26 +3194,28 @@ function assertComposition(value) {
   if (value.overflow !== void 0 && !["warn", "error"].includes(value.overflow)) throw new RangeError("Invalid composition.overflow.");
 }
 function composeSlide(input, options = {}) {
-  const slide = record2(input), layout = record2(options.layout);
+  const 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 hasCards = record2(slide.design).contentBox ?? options.contentBox ?? false;
-  const composition = { ...record2(layout.composition), ...record2(slide.composition) };
+  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 = (composition.minFontSize ?? 16) * scale;
+  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") && record2(slide.design).contentAlignment === void 0 ? record2(slide.design).titleAlignment ?? options.titleAlignment : record2(slide.design).contentAlignment ?? options.contentAlignment) ?? "left";
+  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 = record2(slide.design), deckDesign = record2(record2(options.presentation).design);
+  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" ? (() => {
@@ -1644,15 +3223,18 @@ function composeSlide(input, options = {}) {
     return resolved ? { source: resolved.source, path: resolved.path } : void 0;
   })() : void 0;
   const widthFor = (field, path2) => textWidthMeasurer(styleFor(field, path2), options.textMeasurement);
-  const fitPlacedText = (field, value, text, box, size, minimum, path2) => {
+  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, { style, textMeasurement: options.textMeasurement }) : fitText(text, box, size, minimum, textWidthMeasurer(style, options.textMeasurement));
-    const alignment = alignmentFor(field);
-    const richLayout = rich ? richTextLayouter(value, box, size, { style, textMeasurement: options.textMeasurement }) : void 0;
-    const measure = textWidthMeasurer(style, options.textMeasurement), floor = rich ? richMinimum(value, size, minimum) : minimum, start = Math.max(size, floor);
+    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 fontSize = trial === 64 ? floor : Math.max(floor, start - trial * scale);
-      const fit = richLayout ? richLayout(fontSize) : fitText(text, box, fontSize, fontSize, measure);
+      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;
@@ -1675,7 +3257,7 @@ function composeSlide(input, options = {}) {
         let outline = null;
         for (const segment of line.segments) {
           if (segment.kind === "tab") continue;
-          const bounds = measureTextOutline(text.slice(segment.start, segment.end), fontSize, style, options.textMeasurement);
+          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;
@@ -1689,15 +3271,17 @@ function composeSlide(input, options = {}) {
         }
         return { width: line.width, y: index * fit.lineHeight, baseline: fontSize + index * fit.lineHeight, height: fit.lineHeight, outline };
       });
-      const placement = placeTextLines(lines, box, alignment, rasterPadding), result = { ...fit, placement, overflow: fit.overflow || placement.overflow };
-      if (!result.overflow || fontSize === floor) return result;
+      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, text, box, size, minimum, path2) => field === "text" ? fitPlacedText(field, value, text, box, size, minimum, path2) : field === "items" || field === "bullets" ? fitList(value, box, size, minimum, { style: styleFor(field, path2), textMeasurement: options.textMeasurement, ...bulletImage ? { bulletImage } : {} }) : fitText(text, box, size, minimum, widthFor(field, path2));
+  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);
+  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;
@@ -1707,14 +3291,20 @@ function composeSlide(input, options = {}) {
   const measuredFurniture = layoutFurniture(slide, options);
   const furniture = measuredFurniture.configured || measuredFurniture.diagnostics.length ? measuredFurniture : void 0;
   if (furniture) diagnostics.push(...furniture.diagnostics);
-  const bodyBottom = Math.min(area.bottom - padding, furniture && furniture.footerTop < height ? furniture.footerTop - gap * 0.5 : height - padding);
+  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(record2(slide[key]))) || !emptyPayload(slide.blocks) || fields.some((field) => !emptyPayload(slide[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;
@@ -1722,8 +3312,9 @@ function composeSlide(input, options = {}) {
     const resolved = resolveLogo(options.presentation, slide, { slot: "lockup", onDark: options.darkBackground, slideIndex: options.slideIndex });
     if (resolved) {
       const logoHeight = 56 * scale;
-      const box = { x: round(area.left + padding), y: round(headingTop), width: round(Math.max(scale, Math.min(4 * logoHeight, area.right - area.left - 2 * padding))), height: round(logoHeight) };
-      logo = { box, slot: "lockup", path: resolved.path, source: resolved.source, variant: resolved.variant, anchor: "left" };
+      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;
@@ -1733,10 +3324,10 @@ function composeSlide(input, options = {}) {
     const requested = (field === "title" ? 54 : field === "tag" ? 16 : 25) * scale;
     const maxHeight = Math.max(height * (field === "title" ? 0.26 : field === "subtitle" ? 0.12 : 0.045), minSize * 1.22 + 2 * rasterPadding);
     const box = { x: area.left + padding, y, width: area.right - area.left - padding * 2, height: maxHeight };
-    const text = fitPlacedText(field, slide[field], String(slide[field]), box, requested, minSize, `${path}.${field}`);
-    box.height = Math.min(maxHeight, Math.max(text.lines.length * text.lineHeight, text.placement?.height ?? 0));
+    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, textStyle: styleFor(field, `${path}.${field}`), composition, alignment: alignmentFor(field) };
+    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;
@@ -1756,7 +3347,7 @@ function composeSlide(input, options = {}) {
   const collect = (host, basePath, depth = 0, ancestors = []) => {
     if (Array.isArray(host.blocks)) {
       if (depth >= MAX_COMPOSITION_DEPTH || ancestors.includes(host)) throw new RangeError(`Content groups must be acyclic and nest at most ${MAX_COMPOSITION_DEPTH} levels.`);
-      const settings = record2(host.composition);
+      const settings = record4(host.composition);
       assertComposition(settings);
       return [{
         field: "blocks",
@@ -1765,12 +3356,21 @@ function composeSlide(input, options = {}) {
         path: basePath,
         payload: host,
         composition: settings,
-        children: host.blocks.flatMap((block, index) => collect(record2(block), `${basePath}.blocks.${index}`, depth + 1, [...ancestors, host]))
+        children: host.blocks.flatMap((block, index) => collect(record4(block), `${basePath}.blocks.${index}`, depth + 1, [...ancestors, host]))
       }];
     }
-    return fields.filter((field) => host[field] !== void 0).map((field) => ({ field, type: host.type ?? kind(field), value: host[field], path: `${basePath}.${field}`, payload: { type: host.type ?? kind(field), [field]: host[field] } }));
+    const 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 pending = regions.length ? regions.flatMap((key) => collect(record2(slide[key]), `${path}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => collect(record2(block), `${path}.blocks.${index}`)) : collect(slideImage?.replacesContent ? { ...slide, image: void 0 } : slide, path);
+  const 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 = {}) => ({
@@ -1782,7 +3382,7 @@ function composeSlide(input, options = {}) {
     const amount = (settings.padding ?? 0) * Math.min(box.width, box.height);
     return { x: box.x + amount, y: box.y + amount, width: box.width - amount * 2, height: box.height - amount * 2 };
   };
-  const acceptedBox = (box) => ({ x: round(box.x), y: round(box.y), width: round(box.width), height: round(box.height) });
+  const 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);
@@ -1793,7 +3393,8 @@ function composeSlide(input, options = {}) {
     textMeasurement: options.textMeasurement,
     scale,
     minFontSize: settings.minFontSize,
-    path: node.path
+    path: node.path,
+    direction: textDirection
   });
   const measureCode = (node, box, settings) => layoutCode(node.value, acceptedBox(box), {
     fonts: options.fonts,
@@ -1809,7 +3410,8 @@ function composeSlide(input, options = {}) {
     minFontSize: settings.minFontSize,
     path: node.path,
     textRasterPadding: options.textRasterPadding,
-    align: alignmentFor("metric")
+    align: alignmentFor("metric"),
+    direction: textDirection
   });
   const measureTimeline = (node, box, settings) => layoutTimeline(node.value, acceptedBox(box), {
     fonts: options.fonts,
@@ -1817,13 +3419,20 @@ function composeSlide(input, options = {}) {
     scale,
     minFontSize: settings.minFontSize,
     path: node.path,
-    textRasterPadding: options.textRasterPadding
+    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 text = contentText(node.field, node.value);
-    let score = Math.abs(Math.log(box.width / box.height / 1.6));
-    if (penalties) penalties.cellProportions += score;
+    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);
@@ -1832,9 +3441,9 @@ function composeSlide(input, options = {}) {
         penalties.fontReduction += reduction;
         penalties.textOverflow += internal.overflow ? 1e3 : 0;
       }
-    } else if (text) {
-      const fit = fitContent(node.field, node.value, text, box, 25 * scale, (settings.minFontSize ?? 16) * scale, node.path);
-      const reduction = Math.max(0, 25 * scale - fit.fontSize) / scale;
+    } 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;
@@ -1893,10 +3502,11 @@ function composeSlide(input, options = {}) {
       candidates: candidates ?? []
     });
     const grid = gridGeometry(count, area2, cols, actualGap, settings.weights ?? [], mode === "column");
-    const boxes = grid.boxes;
-    if (recorded && !hasRegions) flows.push({ path: containerPath, box: { ...area2 }, composition: { ...settings }, columns: grid.columns, rows: grid.rows, gap: grid.gap, itemCount: nodes.length, slotCount: count });
+    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 ? regionBox(node.region, area2, actualGap) : boxes[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 });
@@ -1904,13 +3514,18 @@ function composeSlide(input, options = {}) {
       } 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 text = internal ? body?.fit : textValue !== void 0 ? fitContent(node.field, node.value, textValue, box, 25 * scale, (settings.minFontSize ?? 16) * scale, node.path) : void 0;
+        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,
@@ -1919,7 +3534,7 @@ function composeSlide(input, options = {}) {
           payload: node.payload,
           box: internal ? acceptedBox(box) : box,
           ...frameBox ? { frameBox } : {},
-          text,
+          text: text2,
           textStyle: body?.style ?? styleFor(node.field, node.path),
           composition: settings,
           alignment: alignmentFor(node.field),
@@ -1927,7 +3542,8 @@ function composeSlide(input, options = {}) {
           ...codeLayout ? { codeLayout } : {},
           ...metricLayout ? { metricLayout } : {},
           ...timelineLayout ? { timelineLayout } : {},
-          ...bulletImage && (node.field === "items" || node.field === "bullets") ? { bulletImage } : {}
+          ...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." });
       }
@@ -1938,7 +3554,7 @@ function composeSlide(input, options = {}) {
     const picture = placeholders.findIndex((p) => p.type === "picture");
     if (picture >= 0) placeholders.splice(picture, 1);
   }
-  const ownMode = record2(slide.composition).mode;
+  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";
@@ -1952,19 +3568,23 @@ function composeSlide(input, options = {}) {
     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")) {
+  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] = round(item.box[key]);
+    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] = round(box[key]);
+  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;
@@ -1986,8 +3606,8 @@ function composeSlide(input, options = {}) {
     unmeasuredPayloads: items.filter((item) => !headings.has(item.field) && !item.quoteLayout && !item.codeLayout && !item.metricLayout && !item.timelineLayout && !["text", "items", "bullets", "table"].includes(item.field)).map((item) => item.path)
   } : void 0;
   if (failures.length) throw new OPFCompositionError(failures, explanation);
-  diagnostics.push(...slideImageDiagnostics);
-  return { width, height, contentBox, items, groups, flows, diagnostics, composition, ...furniture ? { furniture } : {}, ...slideImage ? { slideImage } : {}, ...logo ? { logo } : {}, ...explanation ? { 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 = {
@@ -1999,7 +3619,7 @@ function resolveCanvasDimensions(input) {
     letter: [11, 8.5],
     a4: [11.69, 8.27]
   };
-  const value = record2(input);
+  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;
@@ -2007,4 +3627,4 @@ function resolveCanvasDimensions(input) {
   return { width, height };
 }
 
-export { DEFAULT_FONT_SCHEME, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_SLIDE_NUMBER_FORMAT, MAX_COMPOSITION_DEPTH, OPFCompositionError, PICTURE_BULLET_SCALE, chartColorForFill, colorContrast, composeSlide, fitList, fitRichText, fitText, formatFurnitureDate, formatSlideNumber, layoutCode, layoutFurniture, layoutMetric, layoutQuote, layoutTable, layoutTimeline, measureText, measureTextOutline, normalizeHexColor, placeTextLines, resolveCanvasDimensions, resolveColorRef, resolveFontFamilies, resolveFontSchemeReference, resolveLogo, resolveSocialProfile, resolveTextStyle, slideImageShape, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, wrapText };
+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 };