@openpresentation/opf 0.13.0 → 0.15.1

package/dist/index.js

@@ -1,1139 +1,809 @@
-export { specFileEntries, specFileKinds, specFilePaths } from './chunk-GJKJL4YY.js';
-export { getLayoutPreview, hasLayoutPreview, layoutPreviewIndex, layoutPreviewSlugs, layoutPreviews } from './chunk-PIQXLBBJ.js';
-export { SYMBOL_FONT_ENCODINGS, SYMBOL_FONT_FAMILIES, isSymbolEncodedFamily, mapSymbolText, symbolCodeForUnicode, symbolCodeOf, symbolFontEncodingFor, symbolUnicodeFor } from './chunk-FYLJVF7X.js';
-export { OPFDataImportError, createDataContent, parseTabularData } from './chunk-ATGDDJPX.js';
-export { OPFPaginationError, paginatePresentation, paginateSlide } from './chunk-RAYB46AB.js';
-export { DEFAULT_AUDIT_THRESHOLDS, DEFAULT_CHART_PALETTE, auditPresentation, auditRules, auditSource, findAuditRule } from './chunk-7N4VMAT4.js';
-export { lintPresentation, lintSource } from './chunk-INU7ZNSB.js';
-export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, validate, validateCatalogRecord, validatePresentation } from './chunk-IYCJUKWD.js';
-import { isRecord, visitContentPayloads, bareIdPattern } from './chunk-MPM7NRG7.js';
-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, DEFAULT_VARIABLE_DATE_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, OPFVariableError, PICTURE_BULLET_SCALE, VARIABLE_KINDS, annotationText, captionSettings, chartColorForFill, chartLabelText, chartNumber, chartOptionSupport, chartOptionTarget, chartPaletteForFill, citationMarkerText, coerceVariableValue, collectCitations, colorContrast, composeSlide, datasetDiagnostics, excelNumberFormat, fitList, fitRichText, fitText, formatChartLabelNumber, formatChartLabelPercent, formatDataNumber, formatFurnitureDate, formatListNumber, formatSlideNumber, formatVariableNumber, hasContentVariables, inlineChartData, inlineDatasets, inlineTableData, isDatasetRef, isTemplate, isXYChartType, layoutCaption, layoutCode, layoutFootnotes, layoutFurniture, layoutMetric, layoutQuote, layoutTimeline, listNumbers, listVariables, measureText, measureTextOutline, normalizeHexColor, numberFormatError, numberFormatFromExcel, numberingAtLevel, numberingStyleDraws, paragraphDirection, paragraphDirectionAt, physicalAlignment, placeTextLines, referencesSlide, resolveCanvasDimensions, resolveChartData, resolveChartOptions, resolveColorRef, resolveFontFamilies, resolveFontSchemeReference, resolveLogo, resolveNumbering, resolveScriptFonts, resolveSlideDirection, resolveSocialProfile, resolveTableData, resolveTextStyle, resolveVariables, scriptFontRole, sliceNumberedItems, slideCitations, snapFontSizeDown, snapFontSizeUp, suggestChartNumberFix, tableCellDisplayValue, textColorForFill, textWidthMeasurer, unusedDatasets, variableDeclarations, walkCitationRuns, wrapText } from './chunk-MPM7NRG7.js';
-import './chunk-S5W34SIJ.js';
-import { catalogEntries } from './chunk-E34DJ5LL.js';
-export { audiences, catalogEntries, catalogIndexes, catalogKinds, catalogSchemaNames, catalogs, chartTypes, colorSchemes, fontSchemes, languages, layouts, narratives, purposes, socialPlatforms, themes, tones } from './chunk-E34DJ5LL.js';
-export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-7QBCWNWL.js';
+export { specFileEntries, specFileKinds, specFilePaths } from './chunk-HXHOZ7AH.js';
+export { OPFDataImportError, importData, parseTabularData } from './chunk-U4J75TRG.js';
+export { fromMarkdown, toMarkdown } from './chunk-3JG4YXWF.js';
+export { OPFMarkdownError } from './chunk-3RKB4RDJ.js';
+export { diff, merge } from './chunk-TWQJLI6E.js';
+export { OPFPatchError, OPFPatchValidationError, applyPatch } from './chunk-5FTUIDUH.js';
+export { OPFFormatError, format } from './chunk-ZPU46TFA.js';
+export { OPFPaginationError, paginate, paginateSlide } from './chunk-UBFJ2QHH.js';
+import './chunk-374R35TJ.js';
+import './chunk-VGAOJEY7.js';
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, resolveSlideContext, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-QDI75P2M.js';
+import { isRecord, visitContentPayloads, listVariables, resolveDesignRecords, resolveFontFamilies, resolveCanvasDimensions, imageBackground } from './chunk-O744SXXA.js';
+export { CHART_TYPES, DEFAULT_VARIABLE_DATE_FORMAT, ENGINE_DEFAULT_CHART_TYPES, ENGINE_DEFAULT_COLOR_SCHEME, ENGINE_DEFAULT_FONT_SCHEME, ENGINE_DEFAULT_THEME, LANGUAGES, OPFVariableError, SOCIAL_PLATFORMS, VARIABLE_KINDS, chartNumber, coerceVariableValue, datasetDiagnostics, formatDataNumber, formatVariableNumber, fromExcelNumberFormat, hasContentVariables, inlineChartData, inlineDatasets, inlineTableData, isDatasetRef, isTemplate, isXYChartType, listBuiltinVariables, listVariables, normalizeLanguageFamily, numberFormatError, resolveChartData, resolveDesignRecords, resolveFontScheme, resolveTableData, resolveVariables, suggestChartNumberFix, tableCellDisplayValue, toExcelNumberFormat, unusedDatasets, variableDeclarations } from './chunk-O744SXXA.js';
+export { catalogDisplayKinds, catalogSchemaNames } from './chunk-TRDXRRQK.js';
+import { embeddedCopy, checkCatalogsOption, catalogReferenceSites, parseReference, catalogGroupDeclared, resolveReference, dottedPath, unresolvedReference, recordReferenceSites, catalogGroupSource, registeredCatalog, catalogKinds, CATALOG_GROUP_PATTERN } from './chunk-SPFV27O5.js';
+export { CATALOG_GROUP_PATTERN, CATALOG_REFERENCE_PATTERN, OPFCatalogsOptionError, OPFUnresolvedReferenceError, catalogGroupSource, catalogKinds, catalogRecords, catalogReferenceSites, parseReference, resolveReference, unresolvedReference } from './chunk-SPFV27O5.js';
+export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-2CJPC4HI.js';
 export { FONT_POLICY, applyFontPolicyDecisions, fontAvailabilityDiagnostics, fontPolicyFor } from './chunk-WXSPETQ6.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);
+// src/catalog-helpers.ts
+var isRec = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var rec = (value) => isRec(value) ? value : {};
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (isRec(value))
+    return `{${Object.keys(value).filter((key) => value[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function sameRecord(a, b) {
+  return canonical(embeddedCopy(a)) === canonical(embeddedCopy(b));
+}
+function setAt(root, path, value) {
+  let node = root;
+  for (const part of path.slice(0, -1)) node = node[part];
+  node[path[path.length - 1]] = value;
+}
+var kindsOf = (group, kind) => {
+  if (!isRec(group[kind])) group[kind] = {};
+  return group[kind];
+};
+function embed(document, options = {}) {
+  const catalogs = { catalogs: checkCatalogsOption(options.catalogs, "embed") };
+  const out = structuredClone(rec(document));
+  const added = [];
+  const unresolved = [];
+  const queue = catalogReferenceSites(out);
+  const reported = /* @__PURE__ */ new Set();
+  while (queue.length) {
+    const site = queue.shift();
+    const parsed = parseReference(site.reference);
+    if (parsed?.group !== void 0 && !catalogGroupDeclared(out, parsed.group)) continue;
+    const found = resolveReference(out, site.kind, site.reference, { ...catalogs, ...site.group !== void 0 ? { group: site.group } : {} });
+    if (!found) {
+      const path = dottedPath(site.path);
+      if (!reported.has(path)) {
+        reported.add(path);
+        unresolved.push(unresolvedReference(out, site.kind, site.reference, path, catalogs));
+      }
+      continue;
     }
-    index.set(entry.kind, records);
+    if (found.origin === "document") continue;
+    if (!isRec(out.catalogs)) out.catalogs = {};
+    const groups = out.catalogs;
+    if (!isRec(groups[found.group])) groups[found.group] = {};
+    const group = groups[found.group];
+    if (found.group !== "custom" && typeof group.source !== "string" && found.source !== void 0) {
+      const rest = { ...group };
+      for (const key of Object.keys(group)) delete group[key];
+      Object.assign(group, { source: found.source }, rest);
+    }
+    const copy = embeddedCopy(found.record);
+    kindsOf(group, site.kind)[found.id] = copy;
+    added.push({ group: found.group, kind: site.kind, id: found.id, ...found.source !== void 0 ? { source: found.source } : {} });
+    queue.push(...recordReferenceSites(site.kind, copy, ["catalogs", found.group, site.kind, found.id], found.group));
   }
-  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);
+  return { document: out, added, unresolved };
+}
+function groupNameFor(source) {
+  const base = source.startsWith("pkg:") ? source.slice(4).replace(/^@/, "").split("/").slice(0, 2).join("-") : (() => {
+    try {
+      return new URL(source).hostname.replace(/^www\./, "");
+    } catch {
+      return source;
+    }
+  })();
+  const name = base.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return /^[a-z]/.test(name) ? name : `catalog-${name || "source"}`;
+}
+function copySlides(from, to, indexes, options = {}) {
+  const catalogs = { catalogs: checkCatalogsOption(options.catalogs, "copySlides") };
+  const source = rec(from);
+  const target = structuredClone(rec(to));
+  const sourceSlides = Array.isArray(source.slides) ? source.slides : [];
+  const targetSlides = Array.isArray(target.slides) ? target.slides : [];
+  for (const index of indexes)
+    if (!Number.isInteger(index) || index < 0 || index >= sourceSlides.length) throw new RangeError(`Slide index ${String(index)} is outside the source presentation's ${sourceSlides.length} slides.`);
+  const at = options.at ?? targetSlides.length;
+  if (!Number.isInteger(at) || at < 0 || at > targetSlides.length) throw new RangeError(`Insertion index ${String(at)} is outside the target presentation's ${targetSlides.length + 1} positions.`);
+  const renamed = [];
+  const addedGroups = [];
+  const added = [];
+  const unresolved = [];
+  const hadCatalogs = isRec(target.catalogs);
+  const groups = () => {
+    if (!isRec(target.catalogs)) target.catalogs = {};
+    return target.catalogs;
+  };
+  const memo = /* @__PURE__ */ new Map();
+  const targetGroupFor = (catalogSource, sourceGroupName) => {
+    for (const [name2, value] of Object.entries(rec(target.catalogs))) if (name2 !== "custom" && isRec(value) && value.source === catalogSource) return name2;
+    if (rec(target.catalogs).default !== false && catalogGroupSource(target, "default", catalogs) === catalogSource) return "default";
+    let name = sourceGroupName === "default" || sourceGroupName === "custom" ? groupNameFor(catalogSource) : sourceGroupName;
+    for (let n = 2; catalogGroupDeclared(target, name) || name === "default" || name === "custom"; n++) name = `${sourceGroupName === "default" ? groupNameFor(catalogSource) : sourceGroupName}-${n}`;
+    groups()[name] = { source: catalogSource };
+    addedGroups.push({ name, source: catalogSource });
+    return name;
+  };
+  const bareTaken = (kind, id) => resolveReference(target, kind, id, catalogs) !== void 0;
+  const addCustom = (kind, wanted, record, renamed2 = false) => {
+    const custom = rec(rec(target.catalogs).custom);
+    const existing = rec(custom[kind]);
+    for (const [id2, value] of Object.entries(existing)) if ((!renamed2 && id2 === wanted || /^-\d+$/.test(id2.slice(wanted.length))) && id2.startsWith(wanted) && sameRecord(value, record)) return { id: id2, reused: true };
+    let n = renamed2 ? 2 : 1;
+    let id = renamed2 ? `${wanted}-2` : wanted;
+    while (Object.hasOwn(existing, id) || bareTaken(kind, id)) id = `${wanted}-${++n}`;
+    if (!isRec(groups().custom)) groups().custom = {};
+    kindsOf(groups().custom, kind)[id] = record;
+    added.push({ group: "custom", kind, id });
+    return { id, reused: false };
+  };
+  const referenceTo = (kind, group, id, holder) => {
+    const found = resolveReference(target, kind, id, { ...catalogs, ...holder !== void 0 ? { group: holder } : {} });
+    return found && found.group === group && found.id === id ? id : `${group}:${id}`;
+  };
+  const place = (kind, reference2, path, holder) => {
+    const found = resolveReference(source, kind, reference2, { ...catalogs, ...holder !== void 0 ? { group: holder } : {} });
+    if (!found) {
+      unresolved.push(unresolvedReference(source, kind, reference2, path, catalogs));
+      return void 0;
+    }
+    const key = `${kind}\0${found.group}\0${found.source ?? ""}\0${found.id}`;
+    const known = memo.get(key);
+    if (known) return known;
+    const incoming = embeddedCopy(found.record);
+    const catalogSource = found.group === "custom" ? void 0 : found.source;
+    const group = catalogSource === void 0 ? "custom" : targetGroupFor(catalogSource, found.group);
+    const inner = recordReferenceSites(kind, incoming, []).map((site) => ({ site, placed: place(site.kind, site.reference, `${path} -> ${site.path.join(".")}`, found.group) }));
+    const rewrite = (holderGroup) => {
+      const copy = structuredClone(incoming);
+      for (const { site, placed: placed2 } of inner) if (placed2) setAt(copy, site.path, referenceTo(site.kind, placed2.group, placed2.id, holderGroup));
+      return copy;
+    };
+    let placed;
+    if (group === "custom") {
+      const result = addCustom(kind, found.id, rewrite("custom"));
+      if (result.id !== found.id && !result.reused) renamed.push({ kind, from: reference2, to: result.id, reason: "custom-conflict" });
+      placed = { group: "custom", id: result.id };
+    } else {
+      const record = rewrite(group);
+      const embedded = rec(rec(rec(target.catalogs)[group])[kind]);
+      const current = Object.hasOwn(embedded, found.id) ? embedded[found.id] : registeredCatalog(catalogGroupSource(target, group, catalogs), catalogs)?.[kind]?.[found.id];
+      if (current === void 0 || sameRecord(current, record)) {
+        if (!Object.hasOwn(embedded, found.id)) {
+          if (!isRec(groups()[group])) groups()[group] = {};
+          const holder2 = groups()[group];
+          if (typeof holder2.source !== "string" && catalogSource !== void 0) {
+            const rest = { ...holder2 };
+            for (const key2 of Object.keys(holder2)) delete holder2[key2];
+            Object.assign(holder2, { source: catalogSource }, rest);
+          }
+          kindsOf(holder2, kind)[found.id] = record;
+          added.push({ group, kind, id: found.id, ...catalogSource !== void 0 ? { source: catalogSource } : {} });
+        }
+        placed = { group, id: found.id };
+      } else {
+        const { id, reused } = addCustom(kind, found.id, rewrite("custom"), true);
+        if (!reused) renamed.push({ kind, from: reference2, to: id, reason: "catalog-revision" });
+        placed = { group: "custom", id };
+      }
     }
+    memo.set(key, placed);
+    return placed;
+  };
+  const copied = [];
+  for (const index of indexes) {
+    const slide = structuredClone(sourceSlides[index]);
+    const holder = { slides: [slide] };
+    for (const site of catalogReferenceSites(holder, { records: false })) {
+      const placed = place(site.kind, site.reference, `slides.${index}.${site.path.slice(2).join(".")}`);
+      if (placed) setAt(holder, site.path, referenceTo(site.kind, placed.group, placed.id));
+    }
+    copied.push(holder.slides[0]);
   }
-  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];
+  targetSlides.splice(at, 0, ...copied);
+  target.slides = targetSlides;
+  if (!hadCatalogs && isRec(target.catalogs) && Object.keys(target.catalogs).length === 0) delete target.catalogs;
+  return { document: target, slides: copied.map((_, offset) => at + offset), renamed, addedGroups, added, unresolved };
+}
+var pointerPart = (part) => part.replaceAll("~", "~0").replaceAll("/", "~1");
+function updateFromCatalog(document, catalogs, refs) {
+  const options = { catalogs: checkCatalogsOption(catalogs, "updateFromCatalog") };
+  const groups = rec(rec(document).catalogs);
+  const wanted = refs?.map((ref) => {
+    const parsed = parseReference(ref.reference);
+    return parsed ? { kind: ref.kind, group: parsed.group ?? "default", id: parsed.id } : void 0;
+  });
+  const changes = [];
+  for (const [group, value] of Object.entries(groups)) {
+    if (group === "custom" || !isRec(value)) continue;
+    const catalogSource = catalogGroupSource(document, group, options);
+    const registered = registeredCatalog(catalogSource, options);
+    if (!registered || catalogSource === void 0) continue;
+    for (const kind of catalogKinds)
+      for (const [id, embedded] of Object.entries(rec(value[kind]))) {
+        if (wanted && !wanted.some((entry) => entry && entry.kind === kind && entry.group === group && entry.id === id)) continue;
+        const current = registered[kind]?.[id];
+        if (current === void 0 || sameRecord(embedded, current)) continue;
+        changes.push({ kind, reference: group === "default" ? id : `${group}:${id}`, group, id, source: catalogSource, embedded: rec(embedded), current: embeddedCopy(current) });
+      }
+  }
+  return {
+    changes,
+    patch: changes.map((change) => ({ op: "replace", path: `/catalogs/${pointerPart(change.group)}/${change.kind}/${pointerPart(change.id)}`, value: change.current }))
+  };
 }
-function bundlePresentation(value) {
-  const report = { added: {}, alreadyInline: {}, keptSources: [], unresolved: {} };
-  if (!isRecord(value)) {
-    return { presentation: value, report };
+var OPFMoveToCustomError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "OPFMoveToCustomError";
+    this.code = code;
   }
-  const presentation2 = structuredClone(value);
-  if (presentation2.catalogs !== void 0 && !isRecord(presentation2.catalogs)) {
-    return { presentation: presentation2, report };
+};
+var pointerOf = (path) => `/${path.map((part) => pointerPart(String(part))).join("/")}`;
+function moveToCustom(document, ref, options = {}) {
+  const catalogs = { catalogs: checkCatalogsOption(options.catalogs, "moveToCustom") };
+  const parsed = parseReference(ref.reference);
+  if (!parsed || !catalogKinds.includes(ref.kind)) throw new OPFMoveToCustomError("invalid-reference", `moveToCustom: ${JSON.stringify(ref.reference)} is not a ${String(ref.kind)} reference (an id or name:id).`);
+  const { kind } = ref;
+  const fromGroup = parsed.group ?? "default";
+  if (fromGroup === "custom") throw new OPFMoveToCustomError("already-custom", `moveToCustom: ${ref.reference} already names a record of catalogs.custom.`);
+  const before = rec(document);
+  const records = rec(rec(rec(before.catalogs)[fromGroup])[kind]);
+  if (!Object.hasOwn(records, parsed.id)) throw new OPFMoveToCustomError("not-embedded", `moveToCustom: catalogs.${fromGroup}.${kind} does not embed ${JSON.stringify(parsed.id)}.`);
+  const fromId = parsed.id;
+  const record = rec(records[fromId]);
+  const sites = catalogReferenceSites(before);
+  const targets = sites.map((site) => resolveReference(before, site.kind, site.reference, { ...catalogs, ...site.group !== void 0 ? { group: site.group } : {} }));
+  const isMoved = (found) => found?.origin === "document" && found.kind === kind && found.group === fromGroup && found.id === fromId;
+  const inMoved = (site) => site.path.length >= 4 && site.path[0] === "catalogs" && site.path[1] === fromGroup && site.path[2] === kind && site.path[3] === fromId;
+  const after = structuredClone(before);
+  const groups = after.catalogs;
+  const custom = rec(groups.custom);
+  const existing = rec(custom[kind]);
+  const moved = structuredClone(record);
+  const ownSites = sites.map((site, index) => ({ site, found: targets[index] })).filter(({ site }) => inMoved(site));
+  if (options.id !== void 0 && (typeof options.id !== "string" || !CATALOG_GROUP_PATTERN.test(options.id))) throw new OPFMoveToCustomError("invalid-id", `moveToCustom: the new id ${JSON.stringify(options.id)} is not a lowercase kebab-case id.`);
+  const wanted = options.id ?? fromId;
+  let toId = wanted;
+  for (let n = 2; Object.hasOwn(existing, toId) && !sameRecord(existing[toId], moved); n++) toId = `${wanted}-${n}`;
+  const reused = Object.hasOwn(existing, toId);
+  const patch = [];
+  const fromRecords = groups[fromGroup][kind];
+  delete fromRecords[fromId];
+  patch.push({ op: "remove", path: pointerOf(["catalogs", fromGroup, kind, fromId]) });
+  if (Object.keys(fromRecords).length === 0) {
+    delete groups[fromGroup][kind];
+    patch.push({ op: "remove", path: pointerOf(["catalogs", fromGroup, kind]) });
   }
-  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);
+  if (!isRec(groups.custom)) {
+    groups.custom = {};
+    patch.push({ op: "add", path: pointerOf(["catalogs", "custom"]), value: {} });
   }
-  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;
+  if (!isRec(groups.custom[kind])) {
+    groups.custom[kind] = {};
+    patch.push({ op: "add", path: pointerOf(["catalogs", "custom", kind]), value: {} });
   }
-  report.keptSources.sort();
-  return { presentation: presentation2, report };
+  const referenceTo = (targetKind, group, id, holder) => {
+    const found = resolveReference(after, targetKind, id, { ...catalogs, ...holder !== void 0 ? { group: holder } : {} });
+    return found && found.group === group && found.id === id ? id : `${group}:${id}`;
+  };
+  if (!reused) {
+    groups.custom[kind][toId] = moved;
+    for (const { site, found } of ownSites) {
+      if (!found) continue;
+      const target = isMoved(found) ? { group: "custom", id: toId } : { group: found.group, id: found.id };
+      setAt(moved, site.path.slice(4), referenceTo(site.kind, target.group, target.id, "custom"));
+    }
+    patch.push({ op: "add", path: pointerOf(["catalogs", "custom", kind, toId]), value: structuredClone(moved) });
+  }
+  const references = [];
+  sites.forEach((site, index) => {
+    if (inMoved(site) || !isMoved(targets[index])) return;
+    const written = referenceTo(kind, "custom", toId, site.group);
+    if (written === site.reference) return;
+    setAt(after, site.path, written);
+    references.push(pointerOf(site.path));
+    patch.push({ op: "replace", path: pointerOf(site.path), value: written });
+  });
+  return {
+    document: after,
+    from: { kind, group: fromGroup, id: fromId, reference: fromGroup === "default" ? fromId : `${fromGroup}:${fromId}` },
+    to: { kind, group: "custom", id: toId, reference: toId },
+    references,
+    patch,
+    ...toId !== wanted ? { renamed: { from: wanted, to: toId } } : {}
+  };
 }
 
-// src/legible-color.ts
-var channels = (hex) => [1, 3, 5].map((offset) => Number.parseInt(hex.slice(offset, offset + 2), 16));
-var toHex = (values) => `#${values.map((value) => Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
-var linear = (value) => {
-  const n = value / 255;
-  return n <= 0.04045 ? n / 12.92 : ((n + 0.055) / 1.055) ** 2.4;
-};
-var luminance = (hex) => {
-  const [r, g, b] = channels(hex);
-  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
+// src/stats.ts
+var DEFAULT_WORDS_PER_MINUTE = 130;
+var KIND_ORDER = ["text", "items", "bullets", "quote", "metric", "code", "timeline", "chart", "table", "image", "video"];
+var FURNITURE_FIELDS = ["logo", "image", "text", "organization", "socials", "section", "slideNumber", "date"];
+var ZONES = ["left", "center", "right"];
+var LOGO_VARIANTS = ["default", "light", "dark", "stacked", "stackedLight", "stackedDark", "icon", "iconLight", "iconDark", "wordmark", "wordmarkLight", "wordmarkDark"];
+var WORD = /[\p{L}\p{N}\p{M}]+(?:['’.,-][\p{L}\p{N}\p{M}]+)*/gu;
+var UNSPACED = /[฀-໿က-႟ក-៿぀-ヿ㐀-䶿一-鿿豈-﫿]/gu;
+var wordCount = (text) => {
+  let extra = 0;
+  const spaced = text.replace(UNSPACED, () => {
+    extra++;
+    return " ";
+  });
+  return (spaced.match(WORD)?.length ?? 0) + extra;
 };
-var contrast = (a, b) => {
-  const x = luminance(a), y = luminance(b);
-  return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
+var sorted = (values) => [...new Set(values)].sort();
+var sortedCounts = (counts) => Object.fromEntries([...counts].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+var bump = (counts, key) => counts.set(key, (counts.get(key) ?? 0) + 1);
+var str = (value) => typeof value === "string" ? value : null;
+var decimals = (value, places) => Math.round(value * 10 ** places) / 10 ** places;
+var reference = (value) => {
+  if (typeof value === "string") return { id: value, inline: false };
+  if (isRecord(value)) return { id: str(value.id), inline: true };
+  return null;
 };
-var normalize = (value) => {
-  if (typeof value !== "string") return void 0;
-  const text = value.trim();
-  if (/^#[0-9a-f]{3}$/i.test(text)) return `#${[...text.slice(1)].map((c) => c + c).join("")}`.toUpperCase();
-  return /^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(text) ? text.slice(0, 7).toUpperCase() : void 0;
+var list = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
+var assetForm = (src) => /^asset:/i.test(src) ? "reference" : /^data:/i.test(src) ? "embedded" : /^(https?:)?\/\//i.test(src) || /^pkg:/i.test(src) ? "remote" : "file";
+var embeddedBytes = (src) => {
+  const comma = src.indexOf(",");
+  if (comma < 0) return 0;
+  const payload = src.slice(comma + 1);
+  if (!/;base64$/i.test(src.slice(0, comma))) return payload.length;
+  const padding = payload.endsWith("==") ? 2 : payload.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor(payload.length * 3 / 4) - padding);
 };
-function toHsl(hex) {
-  const [r, g, b] = channels(hex).map((value) => value / 255);
-  const max = Math.max(r, g, b), min = Math.min(r, g, b), l = (max + min) / 2, d = max - min;
-  if (d === 0) return [0, 0, l];
-  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-  const h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
-  return [h * 60, s, l];
-}
-function fromHsl(h, s, l) {
-  const hue = (h % 360 + 360) % 360, c = (1 - Math.abs(2 * l - 1)) * s, x = c * (1 - Math.abs(hue / 60 % 2 - 1)), m = l - c / 2;
-  const [r, g, b] = hue < 60 ? [c, x, 0] : hue < 120 ? [x, c, 0] : hue < 180 ? [0, c, x] : hue < 240 ? [0, x, c] : hue < 300 ? [x, 0, c] : [c, 0, x];
-  return toHex([(r + m) * 255, (g + m) * 255, (b + m) * 255]);
-}
-function legible(foreground, background, minimum) {
-  if (contrast(foreground, background) >= minimum) return foreground;
-  const [h, s, l] = toHsl(foreground), preferred = luminance(background) < 0.5 ? 1 : -1;
-  for (const direction of [preferred, -preferred]) {
-    for (let step = 1; step <= 100; step++) {
-      const lightness = l + direction * step / 100;
-      if (lightness < 0 || lightness > 1) break;
-      const candidate = fromHsl(h, s, lightness);
-      if (contrast(candidate, background) >= minimum) return candidate;
-    }
+var srcOf = (asset) => typeof asset === "string" ? asset : isRecord(asset) && typeof asset.src === "string" ? asset.src : void 0;
+function slideSize(deck, catalogs) {
+  const design = isRecord(deck.design) ? deck.design : {};
+  const records = resolveDesignRecords(deck, void 0, catalogs);
+  const theme2 = records.theme;
+  const themed = typeof design.theme === "string" && !records.diagnostics.some((diagnostic) => diagnostic.kind === "themes");
+  const source = design.dimensions !== void 0 ? "design" : themed && theme2.dimensions !== void 0 ? "theme" : "default";
+  const dimensions = design.dimensions ?? theme2.dimensions;
+  let width = 40 / 3, height = 7.5;
+  try {
+    const resolved = resolveCanvasDimensions(dimensions);
+    width = resolved.width / 96;
+    height = resolved.height / 96;
+  } catch {
   }
-  return contrast("#FFFFFF", background) >= contrast("#000000", background) ? "#FFFFFF" : "#000000";
-}
-
-// src/code-syntax.ts
-var CODE_HIGHLIGHT_MAX_LENGTH = 2e5;
-var CODE_SYNTAX_MIN_CONTRAST = 4.5;
-var CODE_PANEL_BACKGROUND = "#111827";
-var CODE_PANEL_FOREGROUND = "#E5E7EB";
-var set = (words) => new Set((words ?? "").split(/\s+/).filter(Boolean));
-var JS_KEYWORDS = "break case catch class const continue debugger default delete do else enum export extends finally for from function if import in instanceof let new of return static super switch this throw try typeof var void while with yield async await as get set declare namespace module abstract implements interface private protected public readonly override keyof satisfies type is infer";
-var JS = { line: ["//"], block: [["/*", "*/"]], strings: "'\"`", keywords: JS_KEYWORDS, literals: "true false null undefined NaN Infinity", types: "string number boolean object symbol bigint never unknown any void", defs: { function: "function", class: "type", interface: "type", enum: "type", type: "type" }, capsTypes: true, calls: true, decorators: true };
-var C_LIKE_KEYWORDS = "auto break case catch char class const constexpr continue default delete do double else enum explicit extern false final float for friend goto if inline int long mutable namespace new noexcept nullptr operator override private protected public register return short signed sizeof static struct switch template this throw true try typedef typename union unsigned using virtual void volatile while";
-var LANGUAGES = {
-  javascript: JS,
-  typescript: JS,
-  python: { line: ["#"], strings: `'"`, triple: ['"""', "'''"], keywords: "and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield match case self cls", literals: "True False None", types: "int float str bool bytes list dict set tuple object type", defs: { def: "function", class: "type" }, capsTypes: true, calls: true, decorators: true },
-  rust: { line: ["//"], block: [["/*", "*/"]], strings: '"', rawStrings: "r", keywords: "as async await break const continue crate dyn else enum extern fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait type unsafe use where while", literals: "true false", types: "i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize f32 f64 bool char str String Vec Option Result Box", defs: { fn: "function", struct: "type", enum: "type", trait: "type", type: "type", mod: "type" }, capsTypes: true, calls: true, macros: true },
-  go: { line: ["//"], block: [["/*", "*/"]], strings: "\"'`", noEscapes: "`", keywords: "break case chan const continue default defer else fallthrough for func go goto if import interface map package range return select struct switch type var", literals: "true false nil iota", types: "int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex64 complex128 string bool byte rune error any", defs: { func: "function", type: "type" }, capsTypes: true, calls: true },
-  bash: { line: ["#"], strings: `'"`, noEscapes: "'", keywords: "if then else elif fi for while until do done case esac in function select time return exit break continue export local readonly declare unset set shift source alias trap eval exec", literals: "true false", variables: true, calls: false },
-  json: { line: ["//"], block: [["/*", "*/"]], strings: '"', literals: "true false null", quotedKeys: true },
-  yaml: { kind: "yaml" },
-  toml: { kind: "ini", line: ["#"] },
-  ini: { kind: "ini", line: ["#", ";"] },
-  markup: { kind: "markup" },
-  css: { kind: "css" },
-  sql: { line: ["--"], block: [["/*", "*/"]], strings: `'"`, ci: true, keywords: "add all alter and any as asc between by case check column commit constraint create cross database default delete desc distinct drop else end exists foreign from full group having if in index inner insert into is join key left like limit not null offset on or order outer primary references replace right rollback select set table then top union unique update values view when where with", literals: "true false", types: "int integer bigint smallint decimal numeric float real double varchar char text date time timestamp boolean serial uuid json" },
-  java: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, keywords: "abstract assert break case catch class const continue default do else enum extends final finally for goto if implements import instanceof interface native new package private protected public return static strictfp super switch synchronized this throw throws transient try var volatile while record sealed permits", literals: "true false null", types: "boolean byte char double float int long short void String Object", defs: { class: "type", interface: "type", enum: "type", record: "type" }, capsTypes: true, calls: true, decorators: true },
-  csharp: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, keywords: "abstract as async await base break case catch checked class const continue default delegate do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace new operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw try typeof unchecked unsafe using var virtual volatile while record init required", literals: "true false null", types: "bool byte char decimal double float int long object sbyte short string uint ulong ushort void dynamic", defs: { class: "type", interface: "type", struct: "type", enum: "type", record: "type" }, capsTypes: true, calls: true, decorators: false },
-  kotlin: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, triple: ['"""'], keywords: "abstract actual annotation as break by catch class companion const constructor continue crossinline data do else enum expect external final finally for fun get if import in infix init inline inner interface internal is it lateinit lazy noinline object open operator out override package private protected public reified return sealed set super suspend tailrec this throw try typealias val var vararg when where while", literals: "true false null", types: "Int Long Short Byte Float Double Boolean Char String Unit Any Nothing", defs: { fun: "function", class: "type", interface: "type", object: "type" }, capsTypes: true, calls: true, decorators: true },
-  swift: { line: ["//"], block: [["/*", "*/"]], strings: '"', triple: ['"""'], keywords: "actor as associatedtype async await break case catch class continue default defer deinit do else enum extension fallthrough fileprivate for func guard if import in init inout internal is let nonisolated open operator private protocol public repeat rethrows return self Self static struct subscript super switch throw throws try typealias var where while", literals: "true false nil", types: "Int Double Float Bool String Character Array Dictionary Set Optional Any", defs: { func: "function", class: "type", struct: "type", enum: "type", protocol: "type", extension: "type" }, capsTypes: true, calls: true, decorators: true },
-  ruby: { line: ["#"], strings: `'"`, keywords: "alias and begin break case class def defined do else elsif end ensure for if in module next not or redo rescue retry return self super then undef unless until when while yield require require_relative include extend attr_accessor attr_reader attr_writer private protected public", literals: "true false nil", defs: { def: "function", class: "type", module: "type" }, capsTypes: true, calls: true },
-  php: { line: ["//", "#"], block: [["/*", "*/"]], strings: `'"`, keywords: "abstract and array as break callable case catch class clone const continue declare default do echo else elseif empty enddeclare endfor endforeach endif endswitch endwhile extends final finally fn for foreach function global goto if implements include include_once instanceof insteadof interface isset list match namespace new or print private protected public readonly require require_once return static switch throw trait try unset use var while xor yield", literals: "true false null TRUE FALSE NULL", defs: { function: "function", class: "type", interface: "type", trait: "type" }, capsTypes: true, calls: true, variables: true },
-  c: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, keywords: C_LIKE_KEYWORDS, literals: "true false NULL nullptr", types: "size_t ssize_t int8_t int16_t int32_t int64_t uint8_t uint16_t uint32_t uint64_t bool FILE", calls: true, capsTypes: false, directives: true, defs: { struct: "type", enum: "type", union: "type", class: "type" } },
-  hcl: { line: ["#", "//"], block: [["/*", "*/"]], strings: '"', keywords: "resource data variable output locals module provider terraform for in if else dynamic content backend required_providers lifecycle", literals: "true false null", types: "string number bool list map set object tuple any", calls: true },
-  dockerfile: { line: ["#"], strings: `'"`, keywords: "FROM RUN CMD LABEL MAINTAINER EXPOSE ENV ADD COPY ENTRYPOINT VOLUME USER WORKDIR ARG ONBUILD STOPSIGNAL HEALTHCHECK SHELL AS", variables: true }
-};
-var ALIASES = {
-  js: "javascript",
-  javascript: "javascript",
-  mjs: "javascript",
-  cjs: "javascript",
-  jsx: "javascript",
-  node: "javascript",
-  nodejs: "javascript",
-  ts: "typescript",
-  typescript: "typescript",
-  tsx: "typescript",
-  mts: "typescript",
-  cts: "typescript",
-  python: "python",
-  py: "python",
-  python3: "python",
-  py3: "python",
-  rust: "rust",
-  rs: "rust",
-  go: "go",
-  golang: "go",
-  bash: "bash",
-  sh: "bash",
-  shell: "bash",
-  zsh: "bash",
-  console: "bash",
-  shellscript: "bash",
-  fish: "bash",
-  json: "json",
-  jsonc: "json",
-  json5: "json",
-  yaml: "yaml",
-  yml: "yaml",
-  toml: "toml",
-  ini: "ini",
-  conf: "ini",
-  cfg: "ini",
-  properties: "ini",
-  env: "ini",
-  markup: "markup",
-  html: "markup",
-  xml: "markup",
-  svg: "markup",
-  xhtml: "markup",
-  vue: "markup",
-  plist: "markup",
-  css: "css",
-  scss: "css",
-  less: "css",
-  sass: "css",
-  sql: "sql",
-  postgres: "sql",
-  postgresql: "sql",
-  mysql: "sql",
-  sqlite: "sql",
-  pgsql: "sql",
-  java: "java",
-  csharp: "csharp",
-  cs: "csharp",
-  "c#": "csharp",
-  kotlin: "kotlin",
-  kt: "kotlin",
-  swift: "swift",
-  ruby: "ruby",
-  rb: "ruby",
-  php: "php",
-  c: "c",
-  h: "c",
-  cpp: "c",
-  "c++": "c",
-  cc: "c",
-  cxx: "c",
-  hpp: "c",
-  hh: "c",
-  objc: "c",
-  hcl: "hcl",
-  terraform: "hcl",
-  tf: "hcl",
-  tfvars: "hcl",
-  dockerfile: "dockerfile",
-  docker: "dockerfile"
-};
-var CODE_HIGHLIGHT_LANGUAGES = Object.freeze(Object.keys(LANGUAGES));
-function resolveCodeLanguage(language2) {
-  if (typeof language2 !== "string") return void 0;
-  const key = language2.trim().toLowerCase().replace(/^(?:language|lang)[-:]/, "").replace(/^\./, "");
-  return Object.hasOwn(ALIASES, key) ? ALIASES[key] : void 0;
-}
-var IDENT = /[\p{L}_$][\p{L}\p{N}_$]*/uy;
-var NUMBER = /(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)[a-zA-Z]{0,4}/y;
-var isIdentChar = (character) => character !== void 0 && /[\p{L}\p{N}_$]/u.test(character);
-function endOfLine(source, from) {
-  const index = source.slice(from).search(/\r\n|\r|\n/);
-  return index < 0 ? source.length : from + index;
-}
-function pushToken(tokens, start, end, kind) {
-  if (end <= start) return;
-  const last = tokens[tokens.length - 1];
-  if (last && last.kind === kind && last.end === start && kind !== "function" && kind !== "property") last.end = end;
-  else tokens.push({ start, end, kind });
-}
-function scanQuoted(source, from, quote, escapes, multiline) {
-  let index = from + 1;
-  while (index < source.length) {
-    const character = source[index];
-    if (escapes && character === "\\") {
-      index += 2;
-      continue;
+  const preset = typeof dimensions === "string" ? dimensions : isRecord(dimensions) && typeof dimensions.preset === "string" && dimensions.widthInches === void 0 && dimensions.heightInches === void 0 ? dimensions.preset : null;
+  return { preset, widthInches: decimals(width, 4), heightInches: decimals(height, 4), aspectRatio: decimals(width / height, 3), source };
+}
+var furniture = (value) => {
+  const zones = [], fields = /* @__PURE__ */ new Set();
+  if (isRecord(value))
+    for (const zone of ZONES) {
+      const item = value[zone];
+      if (!isRecord(item)) continue;
+      const present = FURNITURE_FIELDS.filter((field) => item[field] !== void 0 && item[field] !== false);
+      if (present.length) {
+        zones.push(zone);
+        for (const field of present) fields.add(field);
+      }
     }
-    if (character === quote) return index + 1;
-    if (!multiline && (character === "\n" || character === "\r")) return index;
-    index++;
+  return { configured: isRecord(value), suppressed: value === false, zones, fields: FURNITURE_FIELDS.filter((field) => fields.has(field)) };
+};
+function visitRuns(value, visit) {
+  if (typeof value === "string") visit({ text: value });
+  else if (typeof value === "number") visit({ text: String(value) });
+  else if (Array.isArray(value)) for (const entry of value) visitRuns(entry, visit);
+  else if (isRecord(value)) {
+    if (typeof value.text === "string") {
+      visit(value);
+      if (value.description !== void 0) visitRuns(value.description, visit);
+    } else if (Array.isArray(value.text)) {
+      visitRuns(value.text, visit);
+      if (value.description !== void 0) visitRuns(value.description, visit);
+    } else if (value.value !== void 0) visitRuns(value.value, visit);
+    else if (typeof value.name === "string") visit({ text: value.name });
   }
-  return source.length;
 }
-function scanGeneric(source, def) {
-  const tokens = [];
-  const keywords = set(def.keywords), literals = set(def.literals), types = set(def.types);
-  const fold = (word) => def.ci ? word.toLowerCase() : word;
-  if (def.ci) for (const list of [keywords, literals, types]) for (const word of [...list]) {
-    list.delete(word);
-    list.add(word.toLowerCase());
+function stats(presentation2, options = {}) {
+  const catalogs = { catalogs: checkCatalogsOption(options.catalogs, "stats") };
+  if (!isRecord(presentation2)) throw new TypeError("stats needs a presentation object.");
+  const deck = presentation2;
+  const wordsPerMinute = options.wordsPerMinute ?? DEFAULT_WORDS_PER_MINUTE;
+  if (!Number.isFinite(wordsPerMinute) || wordsPerMinute <= 0) throw new RangeError("wordsPerMinute must be a positive number.");
+  const slides = Array.isArray(deck.slides) ? deck.slides.filter(isRecord) : [];
+  const design = isRecord(deck.design) ? deck.design : {};
+  const registry = isRecord(deck.assets) ? deck.assets : {};
+  const uses = { total: 0, references: 0, embedded: 0, files: 0, remote: 0 };
+  let embeddedTotal = 0;
+  const useAsset = (asset) => {
+    const src = srcOf(asset);
+    if (src === void 0) return;
+    const form = assetForm(src);
+    uses.total++;
+    uses[form === "reference" ? "references" : form === "embedded" ? "embedded" : form === "remote" ? "remote" : "files"]++;
+    if (form === "embedded") embeddedTotal += embeddedBytes(src);
+  };
+  const registryFacts = { entries: 0, embedded: 0, files: 0, remote: 0 };
+  for (const entry of Object.values(registry)) {
+    const src = srcOf(entry);
+    if (src === void 0) continue;
+    registryFacts.entries++;
+    const form = assetForm(src);
+    if (form === "embedded") {
+      registryFacts.embedded++;
+      embeddedTotal += embeddedBytes(src);
+    } else if (form === "remote") registryFacts.remote++;
+    else if (form === "file") registryFacts.files++;
   }
-  const strings = def.strings ?? "", lineComments = def.line ?? [], blocks = def.block ?? [], triples = def.triple ?? [];
-  let index = 0, pendingDef;
-  const atLineStart = (position) => {
-    let at = position - 1;
-    while (at >= 0 && (source[at] === " " || source[at] === "	")) at--;
-    return at < 0 || source[at] === "\n" || source[at] === "\r";
+  const altOf = (asset) => {
+    if (isRecord(asset) && typeof asset.alt === "string") return asset.alt;
+    const src = srcOf(asset);
+    if (src?.startsWith("asset:")) {
+      const entry = registry[src.slice("asset:".length)];
+      if (isRecord(entry) && typeof entry.alt === "string") return entry.alt;
+    }
+    return void 0;
   };
-  while (index < source.length) {
-    const character = source[index];
-    if (/\s/.test(character)) {
-      index++;
-      continue;
-    }
-    const lineComment = lineComments.find((opener) => source.startsWith(opener, index));
-    if (lineComment && !(lineComment === "#" && def.directives) && !(lineComment === "#" && def.variables && source[index - 1] === "$") && !(def.variables && lineComment === "#" && index > 0 && !/[\s;&|(]/.test(source[index - 1]))) {
-      const end = endOfLine(source, index);
-      pushToken(tokens, index, end, "comment");
-      index = end;
-      continue;
-    }
-    const block = blocks.find(([opener]) => source.startsWith(opener, index));
-    if (block) {
-      const close = source.indexOf(block[1], index + block[0].length);
-      const end = close < 0 ? source.length : close + block[1].length;
-      pushToken(tokens, index, end, "comment");
-      index = end;
-      continue;
+  const images = { content: { total: 0, withAlt: 0, decorative: 0, missingAlt: 0 }, logos: 0, watermarks: { deck: false, slides: 0 }, backgrounds: { deck: false, slides: 0 }, headerFooter: 0, speakerPhotos: 0, videos: 0 };
+  const contentImage = (asset) => {
+    if (srcOf(asset) === void 0) return 0;
+    useAsset(asset);
+    images.content.total++;
+    const alt = altOf(asset);
+    if (alt === void 0 || alt !== "" && alt.trim() === "") images.content.missingAlt++;
+    else if (alt === "") images.content.decorative++;
+    else images.content.withAlt++;
+    return 1;
+  };
+  const logoImages = (value) => {
+    if (srcOf(value) !== void 0) {
+      useAsset(value);
+      images.logos++;
+      return;
     }
-    if (def.directives && character === "#" && atLineStart(index)) {
-      const match = /#[ \t]*\w+/y;
-      match.lastIndex = index;
-      const found = match.exec(source);
-      if (found) {
-        pushToken(tokens, index, index + found[0].length, "keyword");
-        index += found[0].length;
-        if (/include/.test(found[0])) {
-          const header = /[ \t]*(<[^>\n]*>)/y;
-          header.lastIndex = index;
-          const matched = header.exec(source);
-          if (matched) {
-            const start = index + matched[0].length - matched[1].length;
-            pushToken(tokens, start, start + matched[1].length, "string");
-            index += matched[0].length;
-          }
-        }
-        continue;
+    if (isRecord(value)) {
+      for (const variant of LOGO_VARIANTS) if (srcOf(value[variant]) !== void 0) {
+        useAsset(value[variant]);
+        images.logos++;
       }
     }
-    const triple = triples.find((opener) => source.startsWith(opener, index));
-    if (triple) {
-      const close = source.indexOf(triple, index + 3);
-      const end = close < 0 ? source.length : close + 3;
-      pushToken(tokens, index, end, "string");
-      index = end;
-      pendingDef = void 0;
-      continue;
-    }
-    if (def.rawStrings && character === def.rawStrings && /^r#*"/.test(source.slice(index, index + 8)) && !isIdentChar(source[index - 1])) {
-      const hashes = /^r(#*)"/.exec(source.slice(index, index + 8))[1];
-      const close = source.indexOf(`"${hashes}`, index + 2 + hashes.length);
-      const end = close < 0 ? source.length : close + 1 + hashes.length;
-      pushToken(tokens, index, end, "string");
-      index = end;
-      continue;
-    }
-    if (strings.includes(character)) {
-      if (def === LANGUAGES.rust && character === "'" && !/^'(?:\\.[^']*|[^\\'])'/.test(source.slice(index, index + 12))) {
-        const match = /'[\p{L}_][\p{L}\p{N}_]*/uy;
-        match.lastIndex = index;
-        const found = match.exec(source);
-        const end2 = index + (found ? found[0].length : 1);
-        if (found) pushToken(tokens, index, end2, "type");
-        index = end2;
-        continue;
-      }
-      const escapes = !(def.noEscapes ?? "").includes(character);
-      const multiline = character === "`";
-      const end = scanQuoted(source, index, character, escapes, multiline);
-      let kind = "string";
-      if (def.quotedKeys) {
-        const after = /^[ \t]*:/.exec(source.slice(end, end + 40));
-        if (after) kind = "property";
+  };
+  const watermarkOf = (value) => {
+    if (value === void 0 || value === false) return false;
+    if (srcOf(value) !== void 0) useAsset(value);
+    return srcOf(value) !== void 0;
+  };
+  const backgroundImage = (value) => {
+    const picture = imageBackground(value);
+    if (!picture) return false;
+    useAsset(picture.src);
+    return true;
+  };
+  const furnitureImages = (value) => {
+    if (!isRecord(value)) return;
+    for (const zone of ZONES) {
+      const item = value[zone];
+      if (isRecord(item) && srcOf(item.image) !== void 0) {
+        useAsset(item.image);
+        images.headerFooter++;
       }
-      pushToken(tokens, index, end, kind);
-      index = end;
-      pendingDef = void 0;
-      continue;
     }
-    if (def.variables && character === "$") {
-      const match = /\$(?:\{[^}\n]*\}|[A-Za-z_]\w*|[0-9@#?!$*-])/y;
-      match.lastIndex = index;
-      const found = match.exec(source);
-      if (found) {
-        pushToken(tokens, index, index + found[0].length, "property");
-        index += found[0].length;
-        continue;
-      }
+  };
+  const designAssets = (value, scope) => {
+    if (!isRecord(value)) return;
+    logoImages(value.logo);
+    if (watermarkOf(value.watermark)) {
+      if (scope === "deck") images.watermarks.deck = true;
+      else images.watermarks.slides++;
+    }
+    if (backgroundImage(value.background)) {
+      if (scope === "deck") images.backgrounds.deck = true;
+      else images.backgrounds.slides++;
+    }
+    furnitureImages(value.header);
+    furnitureImages(value.footer);
+  };
+  const organizations = list(deck.organization).filter(isRecord).map((entry) => {
+    const hasLogo = srcOf(entry.logo) !== void 0;
+    if (hasLogo) {
+      useAsset(entry.logo);
+      images.logos++;
     }
-    if (def.decorators && character === "@" && /[\p{L}_]/u.test(source[index + 1] ?? "")) {
-      const match = /@[\p{L}_][\p{L}\p{N}_$.]*/uy;
-      match.lastIndex = index;
-      const found = match.exec(source);
-      pushToken(tokens, index, index + found[0].length, "function");
-      index += found[0].length;
-      continue;
+    return { id: str(entry.id) ?? "", name: str(entry.name) ?? "", role: str(entry.role), hasLogo };
+  });
+  const speakers = list(deck.speaker).filter(isRecord).map((entry) => {
+    const hasPhoto = srcOf(entry.photo) !== void 0;
+    if (hasPhoto) {
+      useAsset(entry.photo);
+      images.speakerPhotos++;
     }
-    if (/\d/.test(character) && !isIdentChar(source[index - 1])) {
-      NUMBER.lastIndex = index;
-      const found = NUMBER.exec(source);
-      if (found) {
-        pushToken(tokens, index, index + found[0].length, "number");
-        index += found[0].length;
-        pendingDef = void 0;
-        continue;
+    return { id: str(entry.id) ?? "", name: str(entry.name) ?? "", title: str(entry.title), organizationId: str(entry.organizationId), hasPhoto };
+  });
+  designAssets(design, "deck");
+  for (const variable of Object.values(isRecord(deck.variables) ? deck.variables : {})) if (isRecord(variable) && variable.type === "image") useAsset(variable.value);
+  const narrative2 = reference(deck.narrative);
+  const deckFacts = {
+    name: str(deck.name),
+    description: typeof deck.description === "string" && deck.description !== "",
+    filename: str(deck.filename),
+    author: list(deck.author).filter((entry) => typeof entry === "string"),
+    language: reference(deck.language),
+    slideSize: slideSize(deck, catalogs),
+    template: deck.template === true,
+    tags: Array.isArray(deck.tags) ? deck.tags.filter((tag) => typeof tag === "string") : [],
+    takeaways: list(deck.takeaway).filter((entry) => typeof entry === "string").length,
+    declaredMinutes: typeof deck.duration === "number" ? deck.duration : null,
+    design: { theme: reference(design.theme), colorScheme: reference(design.colorScheme), fontScheme: reference(design.fontScheme) },
+    audience: list(deck.audience).flatMap((entry) => reference(entry) ?? []),
+    purpose: reference(deck.purpose),
+    tone: reference(deck.tone),
+    narrative: narrative2 ? { ...narrative2, beats: isRecord(deck.narrative) && Array.isArray(deck.narrative.beats) ? deck.narrative.beats.length : 0 } : null
+  };
+  const datasetRecords = isRecord(deck.datasets) ? Object.entries(deck.datasets).filter(([, value]) => isRecord(value)) : [];
+  const datasetUse = /* @__PURE__ */ new Map();
+  const payloadCounts = { text: 0, items: 0, bullets: 0, quote: 0, metric: 0, code: 0, timeline: 0, chart: 0, table: 0, image: 0, video: 0, blocks: 0, regions: 0, groups: 0, maxDepth: 0 };
+  const layouts = /* @__PURE__ */ new Map(), chartTypes = /* @__PURE__ */ new Map(), extensions = /* @__PURE__ */ new Set();
+  const chartData = { inline: 0, dataset: 0, source: 0 };
+  const tableItems = [];
+  let tableRows = 0, tableColumns = 0, datasetBackedTables = 0, chartTotal = 0, captions = 0;
+  const hidden = [], withoutNotes = [], sections = [];
+  let withTitle = 0, withBeat = 0, unsectioned = 0, withoutLayout = 0, withOwnDesign = 0, withNotes = 0, contentWords = 0, notesWords = 0;
+  const headerOverrides = { header: 0, headerSuppressed: 0, footer: 0, footerSuppressed: 0 };
+  const total = { citations: 0, footnotes: 0, links: 0, cited: /* @__PURE__ */ new Set(), families: /* @__PURE__ */ new Set() };
+  const perSlide = [];
+  const contentPerSlide = [];
+  const schemeDesigns = [void 0];
+  slides.forEach((slide, index) => {
+    const id = str(slide.id);
+    const ref = { index, id };
+    const slideDesign = isRecord(slide.design) ? slide.design : void 0;
+    const slideTally = { words: 0, citations: 0, footnotes: 0, links: 0, cited: /* @__PURE__ */ new Set(), families: /* @__PURE__ */ new Set() };
+    const kinds = /* @__PURE__ */ new Set();
+    let slideImages = 0, slideCharts = 0, slideTables = 0;
+    const count = (text) => {
+      slideTally.words += wordCount(text);
+    };
+    const run = (value) => visitRuns(value, (entry) => {
+      count(entry.text);
+      if (typeof entry.link === "string" && entry.link !== "") slideTally.links++;
+      if (entry.cite !== void 0) {
+        slideTally.citations++;
+        for (const cite of list(entry.cite)) if (typeof cite === "string") slideTally.cited.add(cite);
       }
-    }
-    if (def === LANGUAGES.python && /[rRbBfFuU]/.test(character) && /^[rRbBfFuU]{1,2}['"]/.test(source.slice(index, index + 3)) && !isIdentChar(source[index - 1])) {
-      const prefix = /^[rRbBfFuU]{1,2}/.exec(source.slice(index, index + 3))[0].length;
-      const quote = source[index + prefix];
-      const triple2 = source.startsWith(quote.repeat(3), index + prefix);
-      let end;
-      if (triple2) {
-        const close = source.indexOf(quote.repeat(3), index + prefix + 3);
-        end = close < 0 ? source.length : close + 3;
-      } else end = scanQuoted(source, index + prefix, quote, !/[rR]/.test(source.slice(index, index + prefix)), false);
-      pushToken(tokens, index, end, "string");
-      index = end;
-      pendingDef = void 0;
-      continue;
-    }
-    IDENT.lastIndex = index;
-    const identifier = IDENT.exec(source);
-    if (identifier) {
-      const word = identifier[0], end = index + word.length, folded = fold(word);
-      let kind;
-      if (pendingDef && !keywords.has(folded)) kind = pendingDef;
-      else if (keywords.has(folded)) {
-        kind = "keyword";
-        pendingDef = def.defs && Object.hasOwn(def.defs, folded) ? def.defs[folded] : void 0;
-        pushToken(tokens, index, end, kind);
-        index = end;
-        continue;
-      } else if (literals.has(word) || literals.has(folded)) kind = "number";
-      else if (types.has(folded)) kind = "type";
-      else if (def.calls && source[end] === "(") kind = "function";
-      else if (def.macros && source[end] === "!" && /[([{]/.test(source[end + 1] ?? "")) kind = "function";
-      else if (def.capsTypes && /^[A-Z]/.test(word) && /[a-z]/.test(word)) kind = "type";
-      pendingDef = void 0;
-      if (kind) pushToken(tokens, index, end, kind);
-      index = end;
-      continue;
-    }
-    pendingDef = void 0;
-    index++;
-  }
-  return tokens;
-}
-var YAML_LITERALS = /* @__PURE__ */ new Set(["true", "false", "null", "yes", "no", "on", "off", "~", "True", "False", "Null", "TRUE", "FALSE", "NULL"]);
-function scanYamlValue(source, start, end, tokens, comments) {
-  let index = start;
-  while (index < end) {
-    const character = source[index];
-    if (character === "#" && (index === start || /\s/.test(source[index - 1])) && comments.includes("#")) {
-      pushToken(tokens, index, end, "comment");
-      return;
-    }
-    if (character === ";" && comments.includes(";") && (index === start || /\s/.test(source[index - 1]))) {
-      pushToken(tokens, index, end, "comment");
-      return;
-    }
-    if (character === '"' || character === "'") {
-      const close = scanQuoted(source, index, character, character === '"', false);
-      pushToken(tokens, index, Math.min(close, end), "string");
-      index = Math.min(close, end);
-      continue;
-    }
-    if ((character === "&" || character === "*") && /[\w-]/.test(source[index + 1] ?? "")) {
-      const match = /[&*][\w-]+/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      pushToken(tokens, index, index + found2[0].length, "type");
-      index += found2[0].length;
-      continue;
-    }
-    if (!isIdentChar(source[index - 1]) && /[\d-]/.test(character)) {
-      const match = /-?\d[\d_]*(?:\.\d+)?(?:[eE][+-]?\d+)?(?=[\s,\]}]|$)/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2 && index + found2[0].length <= end) {
-        pushToken(tokens, index, index + found2[0].length, "number");
-        index += found2[0].length;
-        continue;
+      if (entry.footnote !== void 0) slideTally.footnotes++;
+      if (typeof entry.fontFamily === "string" && entry.fontFamily !== "") slideTally.families.add(entry.fontFamily);
+    });
+    const caption = (node) => {
+      if (node.caption !== void 0) {
+        captions++;
+        run(node.caption);
       }
-    }
-    const word = /[\w.~-]+/y;
-    word.lastIndex = index;
-    const found = word.exec(source);
-    if (found) {
-      if (YAML_LITERALS.has(found[0]) && !/[\w.-]/.test(source[index + found[0].length] ?? "")) pushToken(tokens, index, index + found[0].length, "number");
-      index += found[0].length;
-      continue;
-    }
-    index++;
-  }
-}
-function lineRanges(source) {
-  const ranges = [];
-  let cursor = 0;
-  const pattern = /\r\n|\r|\n/g;
-  for (let match = pattern.exec(source); match; match = pattern.exec(source)) {
-    ranges.push({ start: cursor, end: match.index });
-    cursor = match.index + match[0].length;
-  }
-  ranges.push({ start: cursor, end: source.length });
-  return ranges;
-}
-function yamlKey(source, from, to) {
-  const first = source[from];
-  if (first === void 0 || from >= to) return void 0;
-  let index = from;
-  if (first === '"' || first === "'") {
-    index = Math.min(scanQuoted(source, from, first, first === '"', false), to);
-    let at = index;
-    while (at < to && (source[at] === " " || source[at] === "	")) at++;
-    return source[index - 1] === first && source[at] === ":" && (at + 1 >= to || /\s/.test(source[at + 1])) ? { nameEnd: index, colon: at } : void 0;
-  }
-  if (/[\s#:{}[\],&*!|>%@`]/.test(first) || first === "-" && /[\s#:]/.test(source[from + 1] ?? " ")) return void 0;
-  for (; index < to; index++) {
-    const character = source[index];
-    if (character === "#" && /\s/.test(source[index - 1])) return void 0;
-    if (character === ":" && (index + 1 >= to || /\s/.test(source[index + 1]))) {
-      let nameEnd = index;
-      while (nameEnd > from && /\s/.test(source[nameEnd - 1])) nameEnd--;
-      return nameEnd > from ? { nameEnd, colon: index } : void 0;
-    }
-  }
-  return void 0;
-}
-function scanYaml(source) {
-  const tokens = [];
-  let blockIndent = -1;
-  for (const { start, end } of lineRanges(source)) {
-    const text = source.slice(start, end), indent = /^ */.exec(text)[0].length;
-    if (blockIndent >= 0) {
-      if (text.trim() === "" || indent > blockIndent) {
-        if (text.trim() !== "") pushToken(tokens, start + indent, end, "string");
-        continue;
+    };
+    const visitNode = (node, path, depth, kind) => {
+      if (kind === "block") payloadCounts.blocks++;
+      if (kind === "region") payloadCounts.regions++;
+      if (kind !== "root" && Array.isArray(node.blocks)) payloadCounts.groups++;
+      if (depth > payloadCounts.maxDepth) payloadCounts.maxDepth = depth;
+      for (const key of KIND_ORDER) if (node[key] !== void 0) {
+        payloadCounts[key]++;
+        kinds.add(key);
       }
-      blockIndent = -1;
-    }
-    if (/^\s*#/.test(text)) {
-      pushToken(tokens, start + indent, end, "comment");
-      continue;
-    }
-    if (/^(?:---|\.\.\.)(?:\s|$)/.test(text)) {
-      pushToken(tokens, start, start + 3, "keyword");
-      scanYamlValue(source, start + 3, end, tokens, "#");
-      continue;
-    }
-    let cursor = start + indent;
-    const dash = /^(?:-\s+)+/.exec(text.slice(indent));
-    if (dash) cursor += dash[0].length;
-    let valueStart = cursor;
-    const key = yamlKey(source, cursor, end);
-    if (key) {
-      pushToken(tokens, cursor, key.nameEnd, "property");
-      valueStart = key.colon + 1;
-    }
-    scanYamlValue(source, valueStart, end, tokens, "#");
-    if (/(?:^|\s)[|>][+-]?\d?\s*(?:#.*)?$/.test(text.slice(valueStart - start))) blockIndent = indent;
-  }
-  return tokens;
-}
-function scanIni(source, def) {
-  const tokens = [], comments = (def.line ?? []).join("");
-  for (const { start, end } of lineRanges(source)) {
-    const text = source.slice(start, end), indent = /^\s*/.exec(text)[0].length, first = text[indent];
-    if (first === void 0) continue;
-    if (comments.includes(first)) {
-      pushToken(tokens, start + indent, end, "comment");
-      continue;
-    }
-    if (first === "[") {
-      const close = text.indexOf("]", indent);
-      const stop = close < 0 ? end : start + close + 1;
-      pushToken(tokens, start + indent, stop, "type");
-      scanYamlValue(source, stop, end, tokens, comments);
-      continue;
-    }
-    const key = /^("[^"\n]*"|'[^'\n]*'|[^\s=:#;"']+(?:\s+[^\s=:#;"']+)*)\s*[=:]/.exec(text.slice(indent));
-    let valueStart = start + indent;
-    if (key) {
-      pushToken(tokens, start + indent, start + indent + key[1].length, "property");
-      valueStart = start + indent + key[0].length;
-    }
-    scanYamlValue(source, valueStart, end, tokens, comments);
-  }
-  return tokens;
-}
-function scanMarkup(source) {
-  const tokens = [];
-  let index = 0;
-  while (index < source.length) {
-    const open = source.indexOf("<", index);
-    if (open < 0) break;
-    if (source.startsWith("<!--", open)) {
-      const close = source.indexOf("-->", open + 4);
-      const end = close < 0 ? source.length : close + 3;
-      pushToken(tokens, open, end, "comment");
-      index = end;
-      continue;
-    }
-    if (source.startsWith("<![CDATA[", open)) {
-      const close = source.indexOf("]]>", open);
-      const end = close < 0 ? source.length : close + 3;
-      pushToken(tokens, open, end, "string");
-      index = end;
-      continue;
-    }
-    const name = /<([/?!]?)([A-Za-z][\w:.-]*|DOCTYPE)?/y;
-    name.lastIndex = open;
-    const found = name.exec(source);
-    if (!found || !found[2]) {
-      index = open + 1;
-      continue;
-    }
-    pushToken(tokens, open + 1, open + found[0].length, "keyword");
-    index = open + found[0].length;
-    while (index < source.length && source[index] !== ">") {
-      const character = source[index];
-      if (character === '"' || character === "'") {
-        const close = source.indexOf(character, index + 1);
-        const end = close < 0 ? source.length : close + 1;
-        pushToken(tokens, index, end, "string");
-        index = end;
-        continue;
+      if (isRecord(node.extensions)) for (const key of Object.keys(node.extensions)) extensions.add(key);
+      run(node.text);
+      run(node.items);
+      run(node.bullets);
+      caption(node);
+      if (node.quote !== void 0) {
+        const quote = node.quote;
+        if (isRecord(quote)) {
+          run(quote.text);
+          run(quote.attribution);
+          run(quote.source);
+        } else run(quote);
       }
-      const attribute = /[A-Za-z_:@#][\w:.@#-]*/y;
-      attribute.lastIndex = index;
-      const matched = attribute.exec(source);
-      if (matched) {
-        pushToken(tokens, index, index + matched[0].length, "property");
-        index += matched[0].length;
-        continue;
+      if (isRecord(node.metric)) {
+        run(node.metric.value);
+        run(node.metric.label);
+        run(node.metric.description);
+        run(node.metric.unit);
+        run(node.metric.delta);
       }
-      index++;
-    }
-    if (source[index] === ">") index++;
-  }
-  return tokens;
-}
-function scanCss(source) {
-  const tokens = [];
-  let index = 0, depth = 0;
-  while (index < source.length) {
-    const character = source[index];
-    if (/\s/.test(character)) {
-      index++;
-      continue;
-    }
-    if (source.startsWith("/*", index)) {
-      const close = source.indexOf("*/", index + 2);
-      const end = close < 0 ? source.length : close + 2;
-      pushToken(tokens, index, end, "comment");
-      index = end;
-      continue;
-    }
-    if (character === '"' || character === "'") {
-      const end = scanQuoted(source, index, character, true, false);
-      pushToken(tokens, index, end, "string");
-      index = end;
-      continue;
-    }
-    if (character === "{") {
-      depth++;
-      index++;
-      continue;
-    }
-    if (character === "}") {
-      depth = Math.max(0, depth - 1);
-      index++;
-      continue;
-    }
-    if (character === "@") {
-      const match = /@[\w-]+/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2) {
-        pushToken(tokens, index, index + found2[0].length, "keyword");
-        index += found2[0].length;
-        continue;
+      if (node.timeline !== void 0) {
+        const timeline = node.timeline, events = Array.isArray(timeline) ? timeline : isRecord(timeline) && Array.isArray(timeline.events) ? timeline.events : [];
+        if (isRecord(timeline)) {
+          run(timeline.name);
+          run(timeline.description);
+        }
+        for (const event of events) if (isRecord(event)) {
+          run(event.when);
+          run(event.what);
+          run(event.description);
+        }
       }
-    }
-    if (character === "!") {
-      const match = /!\s*important/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2) {
-        pushToken(tokens, index, index + found2[0].length, "keyword");
-        index += found2[0].length;
-        continue;
+      if (node.image !== void 0) slideImages += contentImage(node.image);
+      if (node.video !== void 0) {
+        useAsset(node.video);
+        images.videos++;
       }
-    }
-    if (character === "#" && depth > 0) {
-      const match = /#[\da-fA-F]{3,8}\b/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2) {
-        pushToken(tokens, index, index + found2[0].length, "number");
-        index += found2[0].length;
-        continue;
+      if (isRecord(node.chart)) {
+        chartTotal++;
+        slideCharts++;
+        bump(chartTypes, str(node.chart.type) ?? "unknown");
+        const data = node.chart.data;
+        if (isRecord(data)) {
+          if (typeof data.dataset === "string") {
+            chartData.dataset++;
+            bump(datasetUse, data.dataset);
+          } else if (Array.isArray(data.columns) || Array.isArray(data.rows)) chartData.inline++;
+          else if (typeof data.src === "string") {
+            chartData.source++;
+            useAsset(data.src);
+          }
+        }
       }
-    }
-    if (depth > 0 && (/\d/.test(character) || (character === "-" || character === "." || character === "+") && /\d/.test(source[index + 1] ?? ""))) {
-      const match = /[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?(?:%|[a-zA-Z]+)?/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2 && !isIdentChar(source[index - 1])) {
-        pushToken(tokens, index, index + found2[0].length, "number");
-        index += found2[0].length;
-        continue;
+      if (isRecord(node.table)) {
+        slideTables++;
+        const table = node.table;
+        let rows = 0, columns = 0, dataset = null;
+        if (typeof table.dataset === "string") {
+          dataset = table.dataset;
+          datasetBackedTables++;
+          bump(datasetUse, dataset);
+          const source = isRecord(deck.datasets) && isRecord(deck.datasets[dataset]) ? deck.datasets[dataset] : void 0;
+          rows = Array.isArray(source?.rows) ? source.rows.length : 0;
+          columns = Array.isArray(table.fields) ? table.fields.length : Array.isArray(source?.columns) ? source.columns.length : 0;
+        } else {
+          const body = Array.isArray(table.rows) ? table.rows : [];
+          rows = body.length;
+          columns = Array.isArray(table.columns) ? table.columns.length : body.reduce((widest, row) => Math.max(widest, Array.isArray(row) ? row.length : 0), 0);
+          run(table.columns);
+          for (const row of body) run(row);
+        }
+        tableRows += rows;
+        tableColumns += columns;
+        tableItems.push({ slide: index, path: `${path}/table`, rows, columns, dataset });
       }
-    }
-    const word = /-?[\p{L}_][\p{L}\p{N}_-]*/uy;
-    word.lastIndex = index;
-    const found = word.exec(source);
-    if (found) {
-      const end = index + found[0].length;
-      let back = index - 1;
-      while (back >= 0 && /\s/.test(source[back])) back--;
-      const before = back >= 0 ? source[back] : "";
-      if (depth > 0 && /^\s*:(?!:)/.test(source.slice(end, end + 8)) && (before === "{" || before === ";" || before === "")) pushToken(tokens, index, end, "property");
-      else if (source[end] === "(") pushToken(tokens, index, end, "function");
-      index = end;
-      continue;
-    }
-    if (depth === 0 && (character === "." || character === "#")) {
-      const match = /[.#][\p{L}_-][\p{L}\p{N}_-]*/uy;
-      match.lastIndex = index;
-      const matched = match.exec(source);
-      if (matched) {
-        pushToken(tokens, index, index + matched[0].length, "type");
-        index += matched[0].length;
-        continue;
+    };
+    run(slide.title);
+    run(slide.subtitle);
+    run(slide.tag);
+    const slidePath = `/slides/${index}`;
+    visitNode(slide, slidePath, 0, "root");
+    visitContentPayloads(slide, slidePath, (node, path) => {
+      const relative = path.slice(slidePath.length + 1);
+      visitNode(node, path, (relative.match(/(^|\/)blocks\//g) ?? []).length, /(^|\/)blocks\/\d+$/.test(relative) ? "block" : "region");
+    });
+    const notes = typeof slide.notes === "string" ? slide.notes : "";
+    const noteWords = wordCount(notes);
+    const hasNotes = notes.trim() !== "";
+    if (hasNotes) withNotes++;
+    else withoutNotes.push(ref);
+    notesWords += noteWords;
+    contentWords += slideTally.words;
+    contentPerSlide.push(slideTally.words);
+    total.citations += slideTally.citations;
+    total.footnotes += slideTally.footnotes;
+    total.links += slideTally.links;
+    for (const cite of slideTally.cited) total.cited.add(cite);
+    for (const family of slideTally.families) total.families.add(family);
+    const title = typeof slide.title === "string" && slide.title.trim() !== "" ? slide.title : null;
+    if (title) withTitle++;
+    if (slide.beat !== void 0) withBeat++;
+    if (slide.hidden === true) hidden.push(ref);
+    const layout2 = str(slide.layout);
+    if (layout2) bump(layouts, layout2);
+    else withoutLayout++;
+    const section = str(slide.section);
+    if (section !== null && section !== "") {
+      const last = sections.at(-1);
+      if (last && last.name === section && last.firstSlide + last.slides === index) last.slides++;
+      else sections.push({ name: section, slides: 1, firstSlide: index });
+    } else unsectioned++;
+    if (slideDesign) {
+      withOwnDesign++;
+      designAssets(slideDesign, "slide");
+      for (const kind of ["header", "footer"]) {
+        if (slideDesign[kind] === false) headerOverrides[`${kind}Suppressed`]++;
+        else if (isRecord(slideDesign[kind])) headerOverrides[kind]++;
       }
-    }
-    index++;
-  }
-  return tokens;
-}
-function tokenizeCode(source, language2) {
-  const id = resolveCodeLanguage(language2);
-  if (id === void 0 || typeof source !== "string" || source.length === 0 || source.length > CODE_HIGHLIGHT_MAX_LENGTH) return [];
-  const def = LANGUAGES[id];
-  let tokens;
-  switch (def.kind) {
-    case "yaml":
-      tokens = scanYaml(source);
-      break;
-    case "ini":
-      tokens = scanIni(source, def);
-      break;
-    case "markup":
-      tokens = scanMarkup(source);
-      break;
-    case "css":
-      tokens = scanCss(source);
-      break;
-    default:
-      tokens = scanGeneric(source, def);
-  }
-  return tokens.filter((token) => token.end > token.start).sort((a, b) => a.start - b.start);
-}
-function codeLineRuns(tokens, start, end, source) {
-  const runs = [];
-  const push = (from, to, kind) => {
-    if (kind === void 0 || source === void 0 || !source.slice(from, to).includes("	")) {
-      runs.push(kind === void 0 ? { start: from, end: to } : { start: from, end: to, kind });
-      return;
-    }
-    let at = from;
-    for (let index = from; index < to; index++) {
-      if (source[index] !== "	") continue;
-      if (index > at) runs.push({ start: at, end: index, kind });
-      runs.push({ start: index, end: index + 1 });
-      at = index + 1;
-    }
-    if (at < to) runs.push({ start: at, end: to, kind });
-  };
-  let cursor = start;
-  for (const token of tokens) {
-    if (token.end <= start) continue;
-    if (token.start >= end) break;
-    const from = Math.max(token.start, start), to = Math.min(token.end, end);
-    if (from > cursor) push(cursor, from);
-    push(from, to, token.kind);
-    cursor = to;
-  }
-  if (cursor < end) push(cursor, end);
-  return runs;
-}
-var distance = (a, b) => Math.hypot(...channels(a).map((value, index) => value - channels(b)[index]));
-var FALLBACK = { keyword: "#C4B5FD", string: "#86EFAC", number: "#FCD34D", function: "#93C5FD", type: "#67E8F9", property: "#F9A8D4", comment: "#94A3B8" };
-function codeSyntaxPalette(theme2 = {}, options = {}) {
-  const background = normalize(options.background) ?? CODE_PANEL_BACKGROUND, plain = normalize(options.foreground) ?? CODE_PANEL_FOREGROUND;
-  const minimum = options.minimumContrast ?? CODE_SYNTAX_MIN_CONTRAST;
-  const palette = { plain: legible(plain, background, minimum) };
-  const taken = [palette.plain];
-  const slots = [["keyword", theme2.primary], ["string", theme2.accent], ["number", theme2.secondary], ["comment", theme2.mutedText], ["function", void 0], ["type", void 0], ["property", void 0]];
-  for (const [kind, themed] of slots) {
-    const candidates = [normalize(themed), FALLBACK[kind]].filter((value) => value !== void 0).map((value) => legible(value, background, minimum));
-    let [h, s, l] = toHsl(FALLBACK[kind]);
-    let pick = candidates.find((candidate) => taken.every((other) => distance(candidate, other) >= 48));
-    for (let turn = 0; pick === void 0 && turn < 9; turn++) {
-      h += 40;
-      const candidate = legible(fromHsl(h, s, l), background, minimum);
-      if (taken.every((other) => distance(candidate, other) >= 48)) pick = candidate;
-    }
-    palette[kind] = pick ?? candidates[candidates.length - 1];
-    taken.push(palette[kind]);
-  }
-  return palette;
-}
-function codeSyntaxPaletteForScheme(scheme, options = {}) {
-  const record = scheme && typeof scheme === "object" ? scheme : {};
-  const pick = (role, slot, fallback) => normalize(record[role]) ?? normalize(record[slot]) ?? fallback;
-  return codeSyntaxPalette({ primary: pick("primary", "accent1", "#2563EB"), secondary: pick("secondary", "accent2", "#0F766E"), accent: pick("accent", "accent3", "#F59E0B") }, options);
-}
-
-// src/metric-trend.ts
-var METRIC_TREND_SHAPES = Object.freeze({ up: "upArrow", down: "downArrow", flat: "rightArrow" });
-var METRIC_TREND_MIN_CONTRAST = 4.5;
-var SEMANTIC = {
-  up: { light: "#15803D", dark: "#4ADE80" },
-  down: { light: "#B91C1C", dark: "#F87171" }
-};
-function metricTrendColor(trend, options) {
-  const background = normalize(options.background) ?? "#FFFFFF";
-  if (trend === "flat") return legible(normalize(options.neutral) ?? (luminance(background) < 0.5 ? "#CBD5E1" : "#475569"), background, METRIC_TREND_MIN_CONTRAST);
-  const pair = SEMANTIC[trend];
-  return legible(luminance(background) < 0.5 ? pair.dark : pair.light, background, METRIC_TREND_MIN_CONTRAST);
-}
-function metricTrendPoints(shape, box) {
-  const { x: l, y: t, width: w, height: h } = box, r = l + w, b = t + h, hc = l + w / 2, vc = t + h / 2, ss = Math.min(w, h);
-  if (shape === "rightArrow") {
-    const x12 = r - ss * 0.5, y1 = vc - h * 0.25, y22 = vc + h * 0.25;
-    return [[l, y1], [x12, y1], [x12, t], [r, vc], [x12, b], [x12, y22], [l, y22]];
-  }
-  const dy = ss * 0.5, x1 = hc - w * 0.25, x2 = hc + w * 0.25;
-  if (shape === "upArrow") {
-    const y22 = t + dy;
-    return [[l, y22], [hc, t], [r, y22], [x2, y22], [x2, b], [x1, b], [x1, y22]];
-  }
-  const y2 = b - dy;
-  return [[l, y2], [x1, y2], [x1, t], [x2, t], [x2, y2], [r, y2], [hc, b]];
-}
-function metricTrendMark(layout2, options) {
-  const part = layout2.parts.find((candidate) => candidate.role === "trend");
-  if (!part || !part.visible || !part.fit || part.fit.sourceLines.length === 0) return void 0;
-  const trend = part.text.trim();
-  if (!Object.hasOwn(METRIC_TREND_SHAPES, trend)) return void 0;
-  const line = part.fit.sourceLines[0], origin = part.linePositions[0];
-  if (!origin || line.width <= 0) return void 0;
-  const size = part.fit.fontSize * 0.72, gap = part.fit.fontSize * 0.3, left = part.box.x, right = part.box.x + part.box.width;
-  const after = origin.x + line.width + gap, before = origin.x - gap - size;
-  const fitsAfter = after + size <= right + 0.01, fitsBefore = before >= left - 0.01;
-  const x = layout2.alignment === "left" ? fitsAfter ? after : fitsBefore ? before : void 0 : fitsBefore ? before : fitsAfter ? after : void 0;
-  if (x === void 0) return void 0;
-  const shape = METRIC_TREND_SHAPES[trend], box = { x, y: origin.baseline - size, width: size, height: size };
-  return { trend, shape, box, points: metricTrendPoints(shape, box), color: metricTrendColor(trend, options), ariaLabel: `Trend: ${trend}`, path: part.path };
-}
-
-// src/pattern-fills.ts
-var PATTERN_PRESETS = Object.freeze([
-  "pct5",
-  "pct10",
-  "pct20",
-  "pct25",
-  "pct30",
-  "pct40",
-  "pct50",
-  "pct60",
-  "pct70",
-  "pct75",
-  "pct80",
-  "pct90",
-  "horz",
-  "vert",
-  "ltHorz",
-  "ltVert",
-  "dkHorz",
-  "dkVert",
-  "narHorz",
-  "narVert",
-  "dashHorz",
-  "dashVert",
-  "cross",
-  "dnDiag",
-  "upDiag",
-  "ltDnDiag",
-  "ltUpDiag",
-  "dkDnDiag",
-  "dkUpDiag",
-  "wdDnDiag",
-  "wdUpDiag",
-  "dashDnDiag",
-  "dashUpDiag",
-  "diagCross",
-  "smCheck",
-  "lgCheck",
-  "smGrid",
-  "lgGrid",
-  "dotGrid",
-  "smConfetti",
-  "lgConfetti",
-  "horzBrick",
-  "diagBrick",
-  "solidDmnd",
-  "openDmnd",
-  "dotDmnd",
-  "plaid",
-  "sphere",
-  "weave",
-  "divot",
-  "shingle",
-  "wave",
-  "trellis",
-  "zigZag"
-]);
-var PATTERN_PRESET_ALIASES = Object.freeze({ diagStripe: "wdUpDiag" });
-var PATTERN_TILE_SIZE = 8;
-var MEASURED = {
-  pct5: "#......./......../......../......../....#.../......../......../........",
-  pct10: "#......./......../....#.../......../#......./......../....#.../........",
-  pct20: "#...#.../......../..#...#./......../#...#.../......../..#...#./........",
-  pct25: "#...#.../..#...#./#...#.../..#...#./#...#.../..#...#./#...#.../..#...#.",
-  pct30: "#.#.#.#./.#...#../#.#.#.#./...#...#/#.#.#.#./.#...#../#.#.#.#./...#...#",
-  pct40: "#.#.#.#./.#.#.#.#/#.#.#.#./.#.#...#/#.#.#.#./.#.#.#.#/#.#.#.#./...#.#.#",
-  pct50: "#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#",
-  pct60: "###.###./.#.#.#.#/#.###.##/.#.#.#.#/###.###./.#.#.#.#/#.###.##/.#.#.#.#",
-  pct70: ".###.###/##.###.#/.###.###/##.###.#/.###.###/##.###.#/.###.###/##.###.#",
-  pct75: ".###.###/########/##.###.#/########/.###.###/########/##.###.#/########",
-  pct80: "###.####/########/#######./########/###.####/########/#######./########",
-  pct90: "########/########/########/####.###/########/########/########/.#######",
-  horz: "########/......../......../......../......../......../......../........",
-  vert: "#......./#......./#......./#......./#......./#......./#......./#.......",
-  ltHorz: "########/......../......../......../########/......../......../........",
-  ltVert: "#...#.../#...#.../#...#.../#...#.../#...#.../#...#.../#...#.../#...#...",
-  dkHorz: "########/########/......../......../########/########/......../........",
-  dkVert: "##..##../##..##../##..##../##..##../##..##../##..##../##..##../##..##..",
-  narHorz: "########/......../########/......../########/......../########/........",
-  narVert: ".#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#",
-  dashHorz: "####..../......../......../......../....####/......../......../........",
-  dashVert: "#......./#......./#......./#......./....#.../....#.../....#.../....#...",
-  cross: "########/#......./#......./#......./#......./#......./#......./#.......",
-  dnDiag: "#......./.#....../..#...../...#..../....#.../.....#../......#./.......#",
-  upDiag: ".......#/......#./.....#../....#.../...#..../..#...../.#....../#.......",
-  ltDnDiag: "#...#.../.#...#../..#...#./...#...#/#...#.../.#...#../..#...#./...#...#",
-  ltUpDiag: "...#...#/..#...#./.#...#../#...#.../...#...#/..#...#./.#...#../#...#...",
-  dkDnDiag: "##..##../.##..##./..##..##/#..##..#/##..##../.##..##./..##..##/#..##..#",
-  dkUpDiag: "..##..##/.##..##./##..##../#..##..#/..##..##/.##..##./##..##../#..##..#",
-  wdDnDiag: "##.....#/###...../.###..../..###.../...###../....###./.....###/#.....##",
-  wdUpDiag: "#.....##/.....###/....###./...###../..###.../.###..../###...../##.....#",
-  dashDnDiag: "......../......../#...#.../.#...#../..#...#./...#...#/......../........",
-  dashUpDiag: "......../......../...#...#/..#...#./.#...#../#...#.../......../........",
-  diagCross: "#......#/.#....#./..#..#../...##.../...##.../..#..#../.#....#./#......#",
-  smCheck: "#..##..#/.##..##./.##..##./#..##..#/#..##..#/.##..##./.##..##./#..##..#",
-  lgCheck: "####..../####..../####..../####..../....####/....####/....####/....####",
-  smGrid: "########/#...#.../#...#.../#...#.../########/#...#.../#...#.../#...#...",
-  lgGrid: "########/#......./#......./#......./#......./#......./#......./#.......",
-  dotGrid: "#.#.#.#./......../#......./......../#......./......../#......./........",
-  smConfetti: "#......./....#.../.#....../......#./...#..../.......#/..#...../.....#..",
-  lgConfetti: "#.##...#/..##..../......##/...##.##/##.##.../##....../....##../#...##.#",
-  horzBrick: "########/#......./#......./#......./########/....#.../....#.../....#...",
-  diagBrick: ".......#/......#./.....#../....#.../...##.../..#..#../.#....#./#......#",
-  solidDmnd: "...#..../..###.../.#####../#######./.#####../..###.../...#..../........",
-  openDmnd: "#.....#./.#...#../..#.#.../...#..../..#.#.../.#...#../#.....#./.......#",
-  dotDmnd: "#......./......../..#...#./......../....#.../......../..#...#./........",
-  plaid: "#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#/####..../####..../####..../####....",
-  sphere: ".###.###/#...#..#/#...####/#...####/.###.###/#..##.../#####.../#####...",
-  weave: "#...#.../.#.#.#../..#...#./.#...#.#/#...#.../...#.#../..#...#./.#.#...#",
-  divot: "......../...#..../....#.../...#..../......../#......./.......#/#.......",
-  shingle: "......##/#....#../.#..#.../..##..../....##../......#./.......#/.......#",
-  wave: "......../...##.../..#..#.#/##....../......../...##.../..#..#.#/##......",
-  trellis: "########/.##..##./########/#..##..#/########/.##..##./########/#..##..#",
-  zigZag: "#......#/.#....#./..#..#../...##.../#......#/.#....#./..#..#../...##..."
-};
-function rows(preset) {
-  const art = MEASURED[preset];
-  if (!art) return void 0;
-  return art.split("/").map((row) => [...row].reduce((bits, cell, index) => cell === "#" ? bits | 128 >> index : bits, 0));
-}
-var BITMAPS = /* @__PURE__ */ new Map();
-for (const preset of PATTERN_PRESETS) {
-  const bitmap = rows(preset);
-  if (bitmap) BITMAPS.set(preset, Object.freeze(bitmap));
-}
-function resolvePatternPreset(preset) {
-  if (typeof preset !== "string") return void 0;
-  if (BITMAPS.has(preset)) return preset;
-  return Object.hasOwn(PATTERN_PRESET_ALIASES, preset) ? PATTERN_PRESET_ALIASES[preset] : void 0;
-}
-function patternBitmap(preset) {
-  const resolved = resolvePatternPreset(preset);
-  return resolved === void 0 ? void 0 : BITMAPS.get(resolved);
-}
-function patternRuns(preset) {
-  const bitmap = patternBitmap(preset);
-  if (!bitmap) return void 0;
-  const runs = [];
-  bitmap.forEach((row, y) => {
-    for (let x = 0; x < 8; x++) {
-      if (!(row & 128 >> x)) continue;
-      const start = x;
-      while (x + 1 < 8 && row & 128 >> x + 1) x++;
-      runs.push({ x: start, y, width: x - start + 1 });
-    }
+      if (slideDesign.fontScheme !== void 0 || slideDesign.theme !== void 0 && design.fontScheme === void 0) schemeDesigns.push(index);
+    }
+    if (options.perSlide)
+      perSlide.push({
+        index,
+        id,
+        title,
+        layout: layout2,
+        section: section === "" ? null : section,
+        hidden: slide.hidden === true,
+        payloads: KIND_ORDER.filter((kind) => kinds.has(kind)),
+        words: { content: slideTally.words, notes: noteWords },
+        hasNotes,
+        speakingSeconds: Math.round(noteWords / wordsPerMinute * 60),
+        images: slideImages,
+        charts: slideCharts,
+        tables: slideTables,
+        citations: slideTally.citations
+      });
   });
-  return runs;
+  if (isRecord(deck.extensions)) for (const key of Object.keys(deck.extensions)) extensions.add(key);
+  const datasetItems = datasetRecords.map(([id, value]) => ({
+    id,
+    title: str(value.title),
+    columns: Array.isArray(value.columns) ? value.columns.length : 0,
+    rows: Array.isArray(value.rows) ? value.rows.length : 0,
+    source: isRecord(value.source) ? str(value.source.src) : null,
+    referencedBy: datasetUse.get(id) ?? 0
+  }));
+  const references = Array.isArray(deck.references) ? deck.references.filter(isRecord) : [];
+  const referenceIds = references.map((entry) => str(entry.id)).filter((entry) => entry !== null);
+  const cited = referenceIds.filter((entry) => total.cited.has(entry));
+  const variables = listVariables(deck, isRecord(options.values) ? options.values : {});
+  const byKind = /* @__PURE__ */ new Map();
+  for (const variable of variables) bump(byKind, variable.kind);
+  const variableFacts = {
+    declared: variables.length,
+    byKind: sortedCounts(byKind),
+    required: variables.filter((variable) => variable.required).length,
+    optional: variables.filter((variable) => !variable.required).length,
+    filled: variables.filter((variable) => variable.filled).length,
+    unfilled: variables.filter((variable) => !variable.filled).map((variable) => variable.id),
+    unfilledRequired: variables.filter((variable) => !variable.filled && variable.required).map((variable) => variable.id),
+    unused: variables.filter((variable) => variable.uses.length === 0).map((variable) => variable.id)
+  };
+  const families = new Set(total.families), schemeIds = /* @__PURE__ */ new Set(), unresolved = /* @__PURE__ */ new Set();
+  const addScheme = (slideIndex) => {
+    const resolved = resolveDesignRecords(deck, slideIndex, catalogs);
+    for (const diagnostic of resolved.diagnostics) if (diagnostic.kind === "fontSchemes") unresolved.add(diagnostic.reference);
+    if (resolved.fontSchemeReference !== void 0) schemeIds.add(resolved.fontSchemeReference);
+    const scheme = resolved.fontScheme;
+    const named = resolveFontFamilies(scheme);
+    families.add(named.heading);
+    families.add(named.body);
+    if (scheme.code !== void 0) families.add(named.code);
+    if (named.accent) families.add(named.accent);
+  };
+  for (const entry of schemeDesigns) addScheme(entry);
+  const catalogGroups = {};
+  if (isRecord(deck.catalogs))
+    for (const group of Object.keys(deck.catalogs).sort()) {
+      const entry = deck.catalogs[group];
+      if (!isRecord(entry)) continue;
+      const records = {};
+      for (const kind of catalogKinds) if (isRecord(entry[kind])) records[kind] = Object.keys(entry[kind]).length;
+      catalogGroups[group] = { source: str(entry.source), records };
+    }
+  const colorVariables = variables.filter((variable) => variable.kind === "color").map((variable) => ({ id: variable.id, value: typeof variable.value === "string" ? variable.value : null, uses: variable.uses.length }));
+  const contentMean = slides.length ? decimals(contentWords / slides.length, 1) : 0;
+  const result = {
+    deck: deckFacts,
+    people: { organizations, speakers },
+    slides: {
+      total: slides.length,
+      hidden,
+      withTitle,
+      withoutTitle: slides.length - withTitle,
+      withBeat,
+      sections,
+      unsectioned,
+      layouts: sortedCounts(layouts),
+      withoutLayout,
+      withOwnDesign
+    },
+    payloads: payloadCounts,
+    words: {
+      content: contentWords,
+      notes: notesWords,
+      total: contentWords + notesWords,
+      perSlide: { min: contentPerSlide.length ? Math.min(...contentPerSlide) : 0, max: contentPerSlide.length ? Math.max(...contentPerSlide) : 0, mean: contentMean }
+    },
+    notes: { withNotes, withoutNotes },
+    speakingTime: { basis: "estimate", wordsPerMinute, notesWords, minutes: decimals(notesWords / wordsPerMinute, 1), declaredMinutes: deckFacts.declaredMinutes },
+    images,
+    charts: { total: chartTotal, byType: sortedCounts(chartTypes), data: chartData },
+    tables: { total: tableItems.length, datasetBacked: datasetBackedTables, rows: tableRows, columns: tableColumns, items: tableItems },
+    datasets: { count: datasetItems.length, withSource: datasetItems.filter((item) => item.source !== null).length, items: datasetItems },
+    citations: { references: references.length, cited, citations: total.citations, footnotes: total.footnotes, captions, links: total.links },
+    variables: variableFacts,
+    assets: { registry: registryFacts, uses, embeddedBytes: embeddedTotal },
+    headerFooter: {
+      header: furniture(design.header),
+      footer: furniture(design.footer),
+      slides: { headerOverrides: headerOverrides.header, headerSuppressed: headerOverrides.headerSuppressed, footerOverrides: headerOverrides.footer, footerSuppressed: headerOverrides.footerSuppressed }
+    },
+    fonts: { families: sorted(families), schemeIds: sorted(schemeIds), unresolvedSchemeIds: sorted(unresolved), runOverrides: sorted(total.families) },
+    colors: { variables: colorVariables },
+    extensions: sorted(extensions),
+    catalogs: catalogGroups
+  };
+  if (options.perSlide) result.perSlide = perSlide;
+  return result;
 }
 
-export { CODE_HIGHLIGHT_LANGUAGES, CODE_HIGHLIGHT_MAX_LENGTH, CODE_PANEL_BACKGROUND, CODE_PANEL_FOREGROUND, CODE_SYNTAX_MIN_CONTRAST, METRIC_TREND_MIN_CONTRAST, METRIC_TREND_SHAPES, PATTERN_PRESETS, PATTERN_PRESET_ALIASES, PATTERN_TILE_SIZE, bundlePresentation, codeLineRuns, codeSyntaxPalette, codeSyntaxPaletteForScheme, metricTrendColor, metricTrendMark, metricTrendPoints, patternBitmap, patternRuns, resolveCodeLanguage, resolvePatternPreset, tokenizeCode };
+export { OPFMoveToCustomError, copySlides, embed, moveToCustom, sameRecord, stats, updateFromCatalog };