@openpresentation/opf 0.16.0 → 0.18.1

package/dist/chunk-QLFWWHRF.js

@@ -0,0 +1,919 @@
+import { OPFDataImportError, parseTabularData } from './chunk-ZCFSDSUX.js';
+import { applyPatchWithInverse } from './chunk-YZXTXX2D.js';
+import { validate, OPFValidationError } from './chunk-JT3QXA22.js';
+import { isRecord, visitContentPayloads, listVariables, resolveVariables, LOGO_SHAPES, resolveDesignRecords, resolveFontFamilies, resolveCanvasDimensions, imageBackground } from './chunk-MBU42S5Y.js';
+import { embeddedCopy, checkCatalogsOption, catalogReferenceSites, parseReference, catalogGroupDeclared, resolveReference, dottedPath, unresolvedReference, recordReferenceSites, catalogGroupSource, registeredCatalog, catalogKinds, CATALOG_GROUP_PATTERN } from './chunk-SPFV27O5.js';
+
+// src/api-errors.ts
+var OPFApiError = class extends Error {
+  code;
+  details;
+  findings;
+  constructor(message, code, extra = {}) {
+    super(message, extra.cause === void 0 ? void 0 : { cause: extra.cause });
+    this.name = new.target.name;
+    this.code = code;
+    this.details = extra.details ?? {};
+    this.findings = extra.findings ?? [];
+  }
+};
+var OPFExportError = class extends OPFApiError {
+};
+var OPFImportError = class extends OPFApiError {
+};
+function asApiError(Class, error, fallbackCode) {
+  if (error instanceof Class) return error;
+  if (error instanceof OPFApiError) return new Class(error.message, error.code, { details: error.details, findings: error.findings, cause: error });
+  const failure = error;
+  return new Class(failure?.message ?? String(error), typeof failure?.code === "string" ? failure.code : fallbackCode, { cause: error });
+}
+
+// src/slide-selection.ts
+var isSlideNumber = (value) => typeof value === "number" && Number.isInteger(value) && value >= 1;
+function parseSlideSelection(selection, total, label = "slides") {
+  if (!(total >= 1)) throw new OPFApiError("The presentation has no slides.", "no-slides");
+  const listed = typeof selection === "number" ? [selection] : Array.isArray(selection) ? selection : void 0;
+  if (listed) {
+    const bad = listed.find((value) => !isSlideNumber(value));
+    if (bad !== void 0 || listed.length === 0) throw new OPFApiError(`${label} needs slide numbers counted from 1 (got ${JSON.stringify(bad ?? listed)}).`, "invalid-option");
+  } else if (typeof selection !== "string") throw new OPFApiError(`${label} needs a slide number, a list of numbers or text like "1,3-5".`, "invalid-option");
+  const spec = listed ? listed.join(",") : selection;
+  const chosen = /* @__PURE__ */ new Set();
+  for (const part of spec.split(",")) {
+    const text = part.trim();
+    const match = /^(\d*)(-?)(\d*)$/.exec(text);
+    if (!text || !match || !match[1] && !match[3]) throw new OPFApiError(`${label} needs numbers like 1,3-5 (got "${spec}").`, "invalid-option");
+    const [, from, dash, to] = match;
+    const first = from ? Number(from) : 1;
+    const last = dash ? to ? Number(to) : total : first;
+    if (first < 1 || last < first) throw new OPFApiError(`${label} range "${text}" is not valid (slides count from 1).`, "invalid-option");
+    if (last > total) throw new OPFApiError(`${label} ${text} is outside the presentation, which has ${total} slide${total === 1 ? "" : "s"}.`, "invalid-option");
+    for (let n = first; n <= last; n++) chosen.add(n);
+  }
+  return [...chosen].sort((a, b) => a - b);
+}
+
+// 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;
+    }
+    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));
+  }
+  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]);
+  }
+  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 }))
+  };
+}
+var OPFMoveToCustomError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "OPFMoveToCustomError";
+    this.code = code;
+  }
+};
+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]) });
+  }
+  if (!isRec(groups.custom)) {
+    groups.custom = {};
+    patch.push({ op: "add", path: pointerOf(["catalogs", "custom"]), value: {} });
+  }
+  if (!isRec(groups.custom[kind])) {
+    groups.custom[kind] = {};
+    patch.push({ op: "add", path: pointerOf(["catalogs", "custom", kind]), value: {} });
+  }
+  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/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 = ["image", "text", "socials", "date"];
+var ZONES = ["left", "center", "right"];
+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 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 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);
+};
+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 {
+  }
+  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);
+      }
+    }
+  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 });
+  }
+}
+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 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;
+  };
+  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;
+    if (!String(srcOf(asset)).startsWith("var:organization.")) 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 logoAssets = (value) => {
+    if (srcOf(value) !== void 0) return [value];
+    if (!isRecord(value)) return [];
+    return LOGO_SHAPES.flatMap((shape) => {
+      const entry = value[shape];
+      if (srcOf(entry) !== void 0) return [entry];
+      return isRecord(entry) ? [entry.onLight, entry.onDark].filter((tone2) => srcOf(tone2) !== void 0) : [];
+    });
+  };
+  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) continue;
+      if (!String(srcOf(item.image)).startsWith("var:organization.")) useAsset(item.image);
+      images.headerFooter++;
+    }
+  };
+  const designAssets = (value, scope) => {
+    if (!isRecord(value)) return;
+    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 logos = logoAssets(entry.logo);
+    for (const logo of logos) {
+      useAsset(logo);
+      images.logos++;
+    }
+    const hasLogo = logos.length > 0;
+    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++;
+    }
+    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 (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 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);
+      }
+      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);
+      }
+      if (isRecord(node.metric)) {
+        run(node.metric.value);
+        run(node.metric.label);
+        run(node.metric.description);
+        run(node.metric.unit);
+        run(node.metric.delta);
+      }
+      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 (node.image !== void 0) slideImages += contentImage(node.image);
+      if (node.video !== void 0) {
+        useAsset(node.video);
+        images.videos++;
+      }
+      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 (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 });
+      }
+    };
+    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]++;
+      }
+      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
+      });
+  });
+  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;
+}
+
+// src/edit.ts
+function edit(deck, patch, options = {}) {
+  const result = applyPatchWithInverse(deck, patch);
+  const presentation2 = result.presentation;
+  if (options.validate === false) return { presentation: presentation2, findings: [], inverse: result.inverse };
+  const report = validate(presentation2, { only: ["format", "references"], ...options.catalogs ? { catalogs: options.catalogs } : {} });
+  if (!report.valid) throw new OPFValidationError(report);
+  return { presentation: presentation2, findings: report.findings, inverse: result.inverse };
+}
+
+// src/fill.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function fillRecords(raw, options = {}) {
+  const format2 = options.format ?? (/^[\s\uFEFF]*[[{]/.test(raw) ? "json" : "csv");
+  if (format2 === "json") {
+    let value;
+    try {
+      value = JSON.parse(raw.replace(/^\uFEFF/, ""));
+    } catch {
+      throw new OPFDataImportError("Invalid JSON data.");
+    }
+    if (isRecord2(value) && !("columns" in value && "rows" in value)) return [value];
+    if (Array.isArray(value) && value.length && value.every(isRecord2)) return value;
+    if (Array.isArray(value) && !value.length) throw new OPFDataImportError("Data contains no records.");
+  }
+  const table = parseTabularData(raw, { format: format2, header: options.header, delimiter: options.delimiter });
+  if (!table.rows.length) throw new OPFDataImportError("Data contains no records.");
+  return table.rows.map((row) => Object.fromEntries(table.columns.map((column, index) => [column, row[index] === "" ? null : row[index]])));
+}
+function fill(template, data, options = {}) {
+  if (!isRecord2(template)) throw new TypeError("fill expects a template object.");
+  const records = data === void 0 ? [{}] : typeof data === "string" ? fillRecords(data, options) : Array.isArray(data) ? [...data] : [data];
+  if (!records.length) throw new OPFDataImportError("Data contains no records.");
+  if (!records.every(isRecord2)) throw new OPFDataImportError("Each record must be an object keyed by variable id.");
+  const decks = records.map((record, offset) => ({ index: offset + 1, record, ...resolveVariables(template, record, { template: false, partial: options.partial === true, examples: options.examples === true }) }));
+  return {
+    decks: decks.map(({ index, record, presentation: presentation2, diagnostics, unfilled, complete }) => ({ index, record, presentation: presentation2, diagnostics, unfilled, complete })),
+    ...options.combine ? { presentation: combine(decks) } : {},
+    complete: decks.every((deck) => deck.complete),
+    unfilled: [...new Set(decks.flatMap((deck) => deck.unfilled))],
+    diagnostics: summarize(decks)
+  };
+}
+function combine(decks) {
+  const first = decks[0];
+  const seen = /* @__PURE__ */ new Set();
+  const slides = [];
+  const assets = {};
+  for (const deck of decks) {
+    for (const slide of Array.isArray(deck.presentation.slides) ? deck.presentation.slides : []) {
+      if (isRecord2(slide) && typeof slide.id === "string") {
+        let id = slide.id;
+        if (seen.has(id)) {
+          id = `${slide.id}-${deck.index}`;
+          for (let suffix = 2; seen.has(id); suffix++) id = `${slide.id}-${deck.index}-${suffix}`;
+        }
+        seen.add(id);
+        slides.push(id === slide.id ? slide : { ...slide, id });
+      } else slides.push(slide);
+    }
+    if (isRecord2(deck.presentation.assets)) {
+      for (const [key, value] of Object.entries(deck.presentation.assets)) if (!(key in assets)) assets[key] = value;
+    }
+  }
+  return { ...first.presentation, ...Object.keys(assets).length ? { assets } : {}, slides };
+}
+function summarize(decks) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const deck of decks) {
+    for (const diagnostic of deck.diagnostics) {
+      if (diagnostic.severity === "info") continue;
+      const key = `${diagnostic.code}\0${diagnostic.id}\0${diagnostic.path}`;
+      const entry = merged.get(key);
+      if (entry) entry.records.push(deck.index);
+      else merged.set(key, { ...diagnostic, records: [deck.index] });
+    }
+  }
+  return [...merged.values()];
+}
+
+export { OPFApiError, OPFExportError, OPFImportError, OPFMoveToCustomError, asApiError, copySlides, edit, embed, fill, fillRecords, moveToCustom, parseSlideSelection, sameRecord, stats, updateFromCatalog };