@openpresentation/opf 0.10.1 → 0.11.1

package/dist/index.js

@@ -1,9 +1,475 @@
-export { specFileEntries, specFileKinds, specFilePaths } from './chunk-RS5GZ5RW.js';
+export { specFileEntries, specFileKinds, specFilePaths } from './chunk-SDETQV7Y.js';
 export { getLayoutPreview, hasLayoutPreview, layoutPreviewIndex, layoutPreviewSlugs, layoutPreviews } from './chunk-PIQXLBBJ.js';
-export { lintPresentation, lintSource } from './chunk-EWJNRHXA.js';
+export { lintPresentation, lintSource } from './chunk-BP6WMSSS.js';
+export { FONT_POLICY, applyFontPolicyDecisions, fontAvailabilityDiagnostics, fontPolicyFor } from './chunk-NPYN4TZ5.js';
 export { OPFDataImportError, createDataContent, parseTabularData } from './chunk-SOSOBKQ2.js';
-export { OPFPaginationError, paginatePresentation, paginateSlide } from './chunk-FHGJX5QK.js';
-export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, validate, validateCatalogRecord, validatePresentation } from './chunk-ZIL7MGZU.js';
-export { MAX_COMPOSITION_DEPTH, OPFCompositionError, chartColorForFill, colorContrast, composeSlide, fitList, fitRichText, fitText, layoutCode, layoutFurniture, layoutMetric, layoutQuote, layoutTimeline, measureText, measureTextOutline, placeTextLines, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, textColorForFill, textWidthMeasurer, wrapText } from './chunk-PQJRDNA6.js';
-export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-D3GQIREP.js';
-export { audiences, catalogEntries, catalogIndexes, catalogKinds, catalogSchemaNames, catalogs, chartTypes, colorSchemes, fontSchemes, languages, layouts, narratives, purposes, socialPlatforms, themes, tones } from './chunk-TU7I3KSB.js';
+export { OPFPaginationError, paginatePresentation, paginateSlide } from './chunk-KWIOQ3QR.js';
+import { isRecord, visitContentPayloads, bareIdPattern } from './chunk-M4GTWRK7.js';
+export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, validate, validateCatalogRecord, validatePresentation } from './chunk-M4GTWRK7.js';
+import { resolveFontSchemeReference, DEFAULT_FONT_SCHEME, resolveFontFamilies } from './chunk-6UPHKXI5.js';
+export { DEFAULT_FONT_SCHEME, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_SLIDE_NUMBER_FORMAT, MAX_COMPOSITION_DEPTH, OPFCompositionError, chartColorForFill, colorContrast, composeSlide, fitList, fitRichText, fitText, formatFurnitureDate, formatSlideNumber, layoutCode, layoutFurniture, layoutMetric, layoutQuote, layoutTimeline, measureText, measureTextOutline, normalizeHexColor, placeTextLines, resolveCanvasDimensions, resolveColorRef, resolveFontFamilies, resolveFontSchemeReference, resolveSocialProfile, resolveTextStyle, textColorForFill, textWidthMeasurer, wrapText } from './chunk-6UPHKXI5.js';
+export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-LTSDDBNW.js';
+import { catalogs, catalogEntries } from './chunk-7LF37SG3.js';
+export { audiences, catalogEntries, catalogIndexes, catalogKinds, catalogSchemaNames, catalogs, chartTypes, colorSchemes, fontSchemes, languages, layouts, narratives, purposes, socialPlatforms, themes, tones } from './chunk-7LF37SG3.js';
+
+// src/bundle.ts
+function reportKey(kind, id) {
+  return `${kind}:${id}`;
+}
+function referenceId(value) {
+  if (typeof value === "string" && bareIdPattern.test(value)) return value;
+  if (isRecord(value) && typeof value.id === "string" && bareIdPattern.test(value.id)) return value.id;
+  return void 0;
+}
+function addReference(collector, kind, value, reportable) {
+  const id = referenceId(value);
+  if (!id) return;
+  if (reportable) collector.reportable.add(reportKey(kind, id));
+  let ids = collector.referenced.get(kind);
+  if (!ids) {
+    ids = /* @__PURE__ */ new Set();
+    collector.referenced.set(kind, ids);
+  }
+  if (ids.has(id)) return;
+  ids.add(id);
+  collector.queue.push({ kind, id });
+}
+function collectDesignReferences(collector, design) {
+  if (!isRecord(design)) return;
+  addReference(collector, "themes", design.theme, true);
+  addReference(collector, "colorSchemes", design.colorScheme, true);
+  addReference(collector, "fontSchemes", design.fontScheme, true);
+  if (isRecord(design.theme)) {
+    addReference(collector, "colorSchemes", design.theme.colorScheme, true);
+    addReference(collector, "fontSchemes", design.theme.fontScheme, true);
+  }
+}
+function collectChartReference(collector, payload) {
+  if (!isRecord(payload.chart)) return;
+  addReference(collector, "chartTypes", payload.chart.type, typeof payload.chart.type === "string");
+}
+function collectSocialReferences(collector, holder) {
+  const entries = Array.isArray(holder) ? holder : [holder];
+  for (const entry of entries) {
+    if (!isRecord(entry) || !isRecord(entry.socials)) continue;
+    for (const key of Object.keys(entry.socials)) addReference(collector, "socialPlatforms", key, false);
+  }
+}
+function collectBeatReferences(collector, narrative2) {
+  if (!isRecord(narrative2) || !Array.isArray(narrative2.beats)) return;
+  for (const beat of narrative2.beats) {
+    if (isRecord(beat)) addReference(collector, "layouts", beat.layoutHint, false);
+  }
+}
+function collectLanguageReferences(collector, language2) {
+  addReference(collector, "languages", language2, false);
+  if (!isRecord(language2)) return;
+  addReference(collector, "fontSchemes", language2.fontScheme, false);
+  addReference(collector, "fontSchemes", language2.googleFontScheme, false);
+}
+function collectDocumentReferences(collector, document) {
+  addReference(collector, "narratives", document.narrative, typeof document.narrative === "string");
+  collectBeatReferences(collector, document.narrative);
+  addReference(collector, "tones", document.tone, false);
+  addReference(collector, "purposes", document.purpose, false);
+  collectLanguageReferences(collector, document.language);
+  if (Array.isArray(document.audience)) {
+    for (const entry of document.audience) addReference(collector, "audiences", entry, true);
+  } else {
+    addReference(collector, "audiences", document.audience, typeof document.audience === "string");
+  }
+  collectDesignReferences(collector, document.design);
+  collectSocialReferences(collector, document.organization);
+  collectSocialReferences(collector, document.speaker);
+  if (!Array.isArray(document.slides)) return;
+  for (const slide of document.slides) {
+    if (!isRecord(slide)) continue;
+    addReference(collector, "layouts", slide.layout, false);
+    collectDesignReferences(collector, slide.design);
+    collectChartReference(collector, slide);
+    visitContentPayloads(slide, "", (payload) => {
+      collectChartReference(collector, payload);
+    });
+  }
+}
+function collectRecordReferences(collector, kind, record) {
+  if (kind === "themes") {
+    addReference(collector, "colorSchemes", record.colorScheme, false);
+    addReference(collector, "fontSchemes", record.fontScheme, false);
+  } else if (kind === "narratives") {
+    collectBeatReferences(collector, record);
+  } else if (kind === "languages") {
+    addReference(collector, "fontSchemes", record.fontScheme, false);
+    addReference(collector, "fontSchemes", record.googleFontScheme, false);
+  }
+}
+var bundledIndex;
+function bundledCatalogIndex() {
+  if (bundledIndex) return bundledIndex;
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of catalogEntries) {
+    const records = /* @__PURE__ */ new Map();
+    for (const record of entry.records) {
+      if (isRecord(record) && typeof record.id === "string") records.set(record.id, record);
+    }
+    index.set(entry.kind, records);
+  }
+  bundledIndex = index;
+  return index;
+}
+function bundledRecord(kind, id) {
+  const record = bundledCatalogIndex().get(kind)?.get(id);
+  if (!record) return void 0;
+  const clone = structuredClone(record);
+  delete clone.$schema;
+  return clone;
+}
+function readKindState(catalogsField, kind) {
+  const entry = catalogsField[kind];
+  const inline = /* @__PURE__ */ new Map();
+  if (!isRecord(entry)) return { customSource: false, inline };
+  if (Array.isArray(entry.records)) {
+    for (const record of entry.records) {
+      if (isRecord(record) && typeof record.id === "string") inline.set(record.id, record);
+    }
+  }
+  const customSource = typeof entry.source === "string" || Array.isArray(entry.source) && entry.source.length > 0;
+  return { customSource, inline };
+}
+function kindState(states, catalogsField, kind) {
+  const cached = states.get(kind);
+  if (cached) return cached;
+  const state = readKindState(catalogsField, kind);
+  states.set(kind, state);
+  return state;
+}
+function pushReportId(map, kind, id) {
+  const list = map[kind];
+  if (list) list.push(id);
+  else map[kind] = [id];
+}
+function bundlePresentation(value) {
+  const report = { added: {}, alreadyInline: {}, keptSources: [], unresolved: {} };
+  if (!isRecord(value)) {
+    return { presentation: value, report };
+  }
+  const presentation2 = structuredClone(value);
+  if (presentation2.catalogs !== void 0 && !isRecord(presentation2.catalogs)) {
+    return { presentation: presentation2, report };
+  }
+  const catalogsField = isRecord(presentation2.catalogs) ? presentation2.catalogs : {};
+  const collector = { queue: [], referenced: /* @__PURE__ */ new Map(), reportable: /* @__PURE__ */ new Set() };
+  collectDocumentReferences(collector, presentation2);
+  const states = /* @__PURE__ */ new Map();
+  const resolved = /* @__PURE__ */ new Map();
+  for (let index = 0; index < collector.queue.length; index += 1) {
+    const pending = collector.queue[index];
+    if (!pending) continue;
+    const { kind, id } = pending;
+    const state = kindState(states, catalogsField, kind);
+    const inlineRecord = state.inline.get(id);
+    if (inlineRecord) {
+      collectRecordReferences(collector, kind, inlineRecord);
+      continue;
+    }
+    if (state.customSource) continue;
+    const record = bundledRecord(kind, id);
+    if (!record) continue;
+    let kindRecords = resolved.get(kind);
+    if (!kindRecords) {
+      kindRecords = /* @__PURE__ */ new Map();
+      resolved.set(kind, kindRecords);
+    }
+    kindRecords.set(id, record);
+    collectRecordReferences(collector, kind, record);
+  }
+  for (const [kind, ids] of collector.referenced) {
+    const state = kindState(states, catalogsField, kind);
+    if (state.customSource) report.keptSources.push(kind);
+    const kindResolved = resolved.get(kind);
+    const addedIds = [];
+    for (const id of [...ids].sort()) {
+      if (state.inline.has(id)) pushReportId(report.alreadyInline, kind, id);
+      else if (kindResolved?.has(id)) addedIds.push(id);
+      else if (!state.customSource && collector.reportable.has(reportKey(kind, id))) {
+        pushReportId(report.unresolved, kind, id);
+      }
+    }
+    if (!addedIds.length) continue;
+    if (!isRecord(presentation2.catalogs)) presentation2.catalogs = {};
+    const catalogs2 = presentation2.catalogs;
+    if (!isRecord(catalogs2[kind])) catalogs2[kind] = {};
+    const entry = catalogs2[kind];
+    if (!Array.isArray(entry.records)) entry.records = [];
+    const records = entry.records;
+    for (const id of addedIds) records.push(kindResolved?.get(id));
+    report.added[kind] = addedIds;
+  }
+  report.keptSources.sort();
+  return { presentation: presentation2, report };
+}
+
+// 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-]*$/;
+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 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 language2 = first.toLowerCase();
+  if (language2 === "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: language2, 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(language2, region) {
+  const entry = likelyScripts[language2];
+  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, kind) {
+  const kinds = isRecord(document.catalogs) ? document.catalogs : {};
+  const entry = kinds[kind];
+  return isRecord(entry) && Array.isArray(entry.records) ? entry.records.filter(isRecord) : [];
+}
+function allRecords(document, kind) {
+  return [...inlineRecords(document, kind), ...catalogs[kind]];
+}
+function resolveReference(lookup, kind, reference) {
+  if (typeof reference === "string") return lookup(kind, reference);
+  if (!isRecord(reference)) return void 0;
+  const base = typeof reference.id === "string" ? lookup(kind, 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((record) => typeof record.bcp47 === "string");
+  const key = canonicalTag(tag).toLowerCase();
+  const exact = records.find((record) => canonicalTag(record.bcp47).toLowerCase() === key);
+  if (exact) return exact;
+  const language2 = matchingLanguages[wanted.language] ?? wanted.language;
+  const script = wanted.script ?? vendoredScript(language2, wanted.region);
+  const candidates = records.flatMap((record) => {
+    const parts = splitTag(record.bcp47);
+    if (!parts || (matchingLanguages[parts.language] ?? parts.language) !== language2) return [];
+    const recordScript = normalizeScript(record.script) ?? parts.script ?? vendoredScript(language2, parts.region);
+    if (script && recordScript && script !== recordScript) return [];
+    return [{ record, 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 (!isRecord(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 record = { ...base, ...reference };
+  const tag = text(record.bcp47);
+  if (!tag || !splitTag(tag)) return void 0;
+  return { record, authoredTag, authoredOoxmlLang: text(reference.ooxmlLang), languageId: text(base?.id) };
+}
+function pairFamilies(value) {
+  if (!isRecord(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, language2) {
+  const entries = Array.isArray(scheme.languages) ? scheme.languages.filter((entry) => typeof entry === "string") : [];
+  if (entries.length === 0) return true;
+  const name = text(language2.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 = isRecord(input) ? input : {};
+  const lookup = (kind, id) => inlineRecords(document, kind).find((record2) => record2.id === id) ?? catalogs[kind].find((record2) => record2.id === id);
+  let design = isRecord(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 (isRecord(slide) && isRecord(slide.design)) design = { ...design, ...slide.design };
+  }
+  const theme2 = resolveReference(lookup, "themes", design.theme ?? "minimal") ?? {};
+  const scheme = resolveFontSchemeReference(design.fontScheme ?? theme2.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 language2 = fromOption ?? fromDocument ?? resolveLanguage(document, lookup, fallbackTag) ?? { record: {}, authoredTag: fallbackTag };
+  const languageSource = fromOption ? "option" : fromDocument ? "document" : "default";
+  const record = language2.record;
+  const bcp47 = canonicalTag(language2.authoredTag ?? text(record.bcp47) ?? fallbackTag);
+  const curated = text(record.ooxmlLang);
+  const lang = language2.authoredOoxmlLang ? canonicalTag(language2.authoredOoxmlLang) : language2.authoredTag && splitTag(language2.authoredTag)?.region ? canonicalTag(language2.authoredTag) : curated ? canonicalTag(curated) : bcp47;
+  const parts = splitTag(bcp47);
+  const script = normalizeScript(record.script) ?? (language2.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 = record.direction;
+  const direction = declaredDirection === "rtl" || declaredDirection === "ltr" ? declaredDirection : rtlScripts.has(script) ? "rtl" : "ltr";
+  const app = options.app ?? "PowerPoint";
+  const preferred = app === "Google Slides" ? record.googleFontScheme : record.fontScheme;
+  const alternate = app === "Google Slides" ? record.fontScheme : record.googleFontScheme;
+  const languageScheme = resolveReference(lookup, "fontSchemes", preferred) ?? resolveReference(lookup, "fontSchemes", alternate);
+  const languageFamilies = pairFamilies(languageScheme);
+  const schemeAdmitsLanguage = schemeServesLanguage(scheme, record);
+  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,
+    ...language2.languageId ? { languageId: language2.languageId } : {},
+    languageSource,
+    script,
+    scriptRole,
+    direction,
+    rtl: direction === "rtl",
+    heading,
+    body,
+    ...supplement ? { supplement } : {},
+    sources: { eastAsian: eastAsian.source, complexScript: complexScript.source }
+  };
+}
+
+export { bundlePresentation, paragraphDirection, resolveScriptFonts, scriptFontRole };

package/dist/lint.d.ts

@@ -1,7 +1,7 @@
-import { c as CatalogKind } from './catalogs-DoVmvDr7.js';
+import { C as CatalogKind } from './catalogs-DJ-B5ZyD.js';
 import { ValidationIssue } from './validator.js';
-import { J as JsonPrimitive } from './schemas-BYe5y8-i.js';
-import './presentation-BMTdX6O1.js';
+import { J as JsonPrimitive } from './schemas-X_NniU4A.js';
+import './presentation-bceTClm8.js';
 
 type LintSeverity = 'error' | 'warning' | 'info';
 interface LintLocation {

package/dist/lint.js

@@ -1,5 +1,5 @@
-export { lintPresentation, lintSource } from './chunk-EWJNRHXA.js';
-import './chunk-ZIL7MGZU.js';
-import './chunk-PQJRDNA6.js';
-import './chunk-D3GQIREP.js';
-import './chunk-TU7I3KSB.js';
+export { lintPresentation, lintSource } from './chunk-BP6WMSSS.js';
+import './chunk-M4GTWRK7.js';
+import './chunk-6UPHKXI5.js';
+import './chunk-LTSDDBNW.js';
+import './chunk-7LF37SG3.js';

package/dist/pagination.d.ts

@@ -1,11 +1,11 @@
-import { LayoutDiagnostic, ComposeSlideOptions, TextMeasurement } from './composition.js';
+import { L as LayoutDiagnostic, C as ComposeSlideOptions, T as TextMeasurement, F as FontSchemeDiagnostic } from './composition-DzLwY-Mi.js';
 
 interface PaginationOptions extends ComposeSlideOptions {
     /** Readability floor used while choosing page breaks. Default 24 reference pixels. */
     minFontSize?: number;
     /** All-or-nothing resource limit. Defaults to 100 output slides. */
     maxSlides?: number;
-    /** Existing deck IDs to avoid when generating continuation IDs. */
+    /** Existing slide and content payload IDs to avoid when generating continuation IDs. */
     reservedIds?: string[];
 }
 interface PaginationMapping {
@@ -41,8 +41,12 @@ interface PresentationPaginationOptions {
     textRasterPadding?: number;
     minFontSize?: number;
     maxSlides?: number;
+    /** Host-supplied current calendar date (ISO YYYY-MM-DD) for `date: true` header/footer fields. */
+    date?: string;
     /** Optional host-resolved layout/canvas overrides for each source slide. */
     slideOptions?: (slide: Record<string, any>, index: number) => ComposeSlideOptions;
+    /** Receives `unresolved-font-scheme` once per reference path when a font-scheme id matches no record. */
+    onDiagnostic?: (diagnostic: FontSchemeDiagnostic) => void;
 }
 interface PresentationPaginationResult {
     presentation: Record<string, any>;

package/dist/pagination.js

@@ -1,5 +1,5 @@
-export { OPFPaginationError, paginatePresentation, paginateSlide } from './chunk-FHGJX5QK.js';
-import './chunk-ZIL7MGZU.js';
-import './chunk-PQJRDNA6.js';
-import './chunk-D3GQIREP.js';
-import './chunk-TU7I3KSB.js';
+export { OPFPaginationError, paginatePresentation, paginateSlide } from './chunk-KWIOQ3QR.js';
+import './chunk-M4GTWRK7.js';
+import './chunk-6UPHKXI5.js';
+import './chunk-LTSDDBNW.js';
+import './chunk-7LF37SG3.js';