@openpresentation/opf 0.11.3 → 0.12.0

package/dist/chunk-UQKJWHSS.js

@@ -0,0 +1,1332 @@
+import { promotedRegionKeys, isRecord, collectCitations, parseIsoDate, pathFor, MAX_COMPOSITION_DEPTH, visitContentPayloads, tableGrid, numberingFindings, walkCitationRuns, bareIdPattern, catalogIds, deprecatedCatalogIds, resolveChartOptions, chartOptionTarget, formatFurnitureDate } from './chunk-6TSDIPSH.js';
+import { catalogSchemaNames } from './chunk-3ZGSWEHK.js';
+import { schemas, schemaEntries } from './chunk-RVN5C2FX.js';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+
+// src/annotation-validation.ts
+var issue = (path, message, params) => ({ path, message, keyword: "opf", schemaPath: "#/x-opf-semantics", params });
+var pointer = (dotted) => `/${dotted.split(".").map((part) => part.replaceAll("~", "~0").replaceAll("/", "~1")).join("/")}`;
+function markedRuns(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((run, index) => isRecord(run) && (run.cite !== void 0 || run.footnote !== void 0) ? [index] : []);
+}
+function annotationIssues(value) {
+  if (!isRecord(value) || !Array.isArray(value.slides)) return [];
+  const issues = [];
+  const ids = /* @__PURE__ */ new Set();
+  if (Array.isArray(value.references)) value.references.forEach((reference, index) => {
+    if (!isRecord(reference) || typeof reference.id !== "string") return;
+    if (ids.has(reference.id)) issues.push(issue(`/references/${index}/id`, `reference id '${reference.id}' is used by an earlier references entry; ids must be unique`, { code: "reference-id-duplicate", id: reference.id }));
+    ids.add(reference.id);
+    for (const runIndex of markedRuns(reference.text)) issues.push(issue(`/references/${index}/text/${runIndex}`, "reference text cannot cite or carry a footnote", { code: "cite-unsupported-location" }));
+  });
+  const unsupported = (runs, path, where) => {
+    for (const runIndex of markedRuns(runs)) issues.push(issue(`${path}/${runIndex}`, `cite and footnote are not supported in ${where}; markers are drawn only in text, bullets and list items`, { code: "cite-unsupported-location" }));
+  };
+  const cell = (entry, path) => {
+    if (Array.isArray(entry)) unsupported(entry, path, "table cells");
+    else if (isRecord(entry) && Array.isArray(entry.value)) unsupported(entry.value, pathFor(path, "value"), "table cells");
+  };
+  const payload = (node, path) => {
+    if (isRecord(node.table)) {
+      const table = node.table, tablePath = pathFor(path, "table");
+      if (Array.isArray(table.columns)) table.columns.forEach((column, index) => {
+        cell(column, `${pathFor(tablePath, "columns")}/${index}`);
+      });
+      if (Array.isArray(table.rows)) table.rows.forEach((row, rowIndex) => {
+        if (Array.isArray(row)) row.forEach((entry, cellIndex) => {
+          cell(entry, `${pathFor(tablePath, "rows")}/${rowIndex}/${cellIndex}`);
+        });
+      });
+    }
+    if (node.caption !== void 0) {
+      const caption = node.caption, captionPath = pathFor(path, "caption");
+      if (Array.isArray(caption)) unsupported(caption, captionPath, "captions");
+      else if (isRecord(caption) && Array.isArray(caption.text)) unsupported(caption.text, pathFor(captionPath, "text"), "captions");
+    }
+  };
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    const slidePath = `/slides/${index}`;
+    payload(slide, slidePath);
+    visitContentPayloads(slide, slidePath, payload);
+    walkCitationRuns(slide, `slides.${index}`, (entry) => {
+      const runPath = pointer(entry.path);
+      const cite = entry.run.cite;
+      if (typeof cite === "string") {
+        if (!ids.has(cite)) issues.push(issue(`${runPath}/cite`, `unknown reference '${cite}'; add it to the top-level references list`, { code: "cite-unknown-reference", id: cite }));
+      } else if (Array.isArray(cite)) cite.forEach((id, position) => {
+        if (typeof id === "string" && !ids.has(id)) issues.push(issue(`${runPath}/cite/${position}`, `unknown reference '${id}'; add it to the top-level references list`, { code: "cite-unknown-reference", id }));
+      });
+      if (Array.isArray(entry.footnote)) unsupported(entry.footnote, `${runPath}/footnote`, "footnote text");
+    });
+  });
+  return issues;
+}
+function unusedReferenceWarnings(value) {
+  if (!isRecord(value) || !Array.isArray(value.references) || !Array.isArray(value.slides)) return [];
+  const { unused } = collectCitations(value);
+  return value.references.flatMap((reference, index) => isRecord(reference) && typeof reference.id === "string" && unused.includes(reference.id) ? [issue(`/references/${index}`, `reference '${reference.id}' is never cited; cite it with a run's cite field or remove it`, { code: "unused-reference", id: reference.id })] : []);
+}
+
+// src/validation-definitions.ts
+var schemaLocations;
+var issueLocations = /* @__PURE__ */ new WeakMap();
+function rememberValidationDefinition(issue2, parentSchema, keyword) {
+  if (!parentSchema || typeof parentSchema !== "object") return;
+  if (!schemaLocations) {
+    schemaLocations = /* @__PURE__ */ new WeakMap();
+    for (const entry of schemaEntries) {
+      const stack = [
+        { value: entry.schema, pointer: "" }
+      ];
+      while (stack.length) {
+        const current = stack.pop();
+        if (!current?.value || typeof current.value !== "object")
+          continue;
+        schemaLocations.set(current.value, {
+          schemaName: entry.name,
+          pointer: current.pointer,
+          uri: `${entry.schema.$id}#${current.pointer}`
+        });
+        for (const [key, value] of Object.entries(current.value)) {
+          const segment = key.replaceAll("~", "~0").replaceAll("/", "~1");
+          stack.push({ value, pointer: `${current.pointer}/${segment}` });
+        }
+      }
+    }
+  }
+  const parent = schemaLocations.get(parentSchema);
+  if (!parent) return;
+  const suffix = `/${keyword.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+  issueLocations.set(issue2, {
+    ...parent,
+    pointer: parent.pointer + suffix,
+    uri: parent.uri + suffix
+  });
+}
+function validationDefinition(issue2) {
+  return issueLocations.get(issue2);
+}
+
+// src/variables.ts
+var VARIABLE_KINDS = ["color", "text", "number", "date", "image", "url", "list"];
+var DEFAULT_VARIABLE_DATE_FORMAT = "MMMM d, yyyy";
+var OPFVariableError = class extends Error {
+  diagnostics;
+  constructor(diagnostics) {
+    const first = diagnostics.find((entry) => entry.severity === "error") ?? diagnostics[0];
+    super(first ? `OPF variables: ${first.message}` : "OPF variables failed");
+    this.name = "OPFVariableError";
+    this.diagnostics = diagnostics;
+  }
+};
+var idPattern = /^[a-z][a-z0-9-]*$/;
+var referencePattern = /^var:([a-z][a-z0-9-]*)$/;
+var hexPattern = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var urlPattern = /^(?:https?:\/\/|mailto:|tel:)\S+$/;
+var datePrefixPattern = /^(\d{4}-\d{2}-\d{2})(?:[T ].*)?$/;
+var decimalPattern = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var tokenPattern = /\\\{\{|\{\{\s*([a-z][a-z0-9-]*)\s*(?:\|([^{}]*))?\}\}/g;
+var SAMPLES = {
+  color: "#000000",
+  text: "Sample text",
+  number: 0,
+  date: "2000-01-01",
+  image: "https://example.invalid/sample.png",
+  url: "https://example.invalid/",
+  list: ["Sample item"]
+};
+var hasOwn = (value, key) => Object.hasOwn(value, key);
+var clone = (value) => value === void 0 ? value : JSON.parse(JSON.stringify(value));
+function isTemplate(presentation) {
+  return isRecord(presentation) && presentation.template === true;
+}
+function isKind(value) {
+  return typeof value === "string" && VARIABLE_KINDS.includes(value);
+}
+function coerceVariableValue(kind, raw) {
+  const fail = (message) => ({ ok: false, message });
+  switch (kind) {
+    case "color":
+      return typeof raw === "string" && hexPattern.test(raw.trim()) ? { ok: true, value: raw.trim() } : fail("expected a hex color such as #0F4C81");
+    case "text": {
+      if (typeof raw === "string") return { ok: true, value: raw };
+      if (typeof raw === "number" && Number.isFinite(raw)) return { ok: true, value: String(raw) };
+      if (typeof raw === "boolean") return { ok: true, value: String(raw) };
+      if (Array.isArray(raw) && raw.every((run) => typeof run === "string" || isRecord(run) && typeof run.text === "string")) return { ok: true, value: clone(raw) };
+      return fail("expected text: a string or an array of text runs");
+    }
+    case "number": {
+      if (typeof raw === "number" && Number.isFinite(raw)) return { ok: true, value: raw };
+      if (typeof raw === "string" && decimalPattern.test(raw.trim())) {
+        const value = Number(raw.trim());
+        if (Number.isFinite(value)) return { ok: true, value };
+      }
+      return fail("expected a finite number");
+    }
+    case "date": {
+      if (typeof raw === "string") {
+        const match = datePrefixPattern.exec(raw.trim());
+        if (match?.[1] && parseIsoDate(match[1])) return { ok: true, value: match[1] };
+      }
+      return fail("expected an ISO calendar date (YYYY-MM-DD)");
+    }
+    case "image": {
+      if (typeof raw === "string" && raw.trim()) return { ok: true, value: raw.trim() };
+      if (isRecord(raw) && typeof raw.src === "string" && raw.src.trim()) return { ok: true, value: clone(raw) };
+      return fail("expected an image source: a string or an object with src");
+    }
+    case "url":
+      return typeof raw === "string" && urlPattern.test(raw.trim()) ? { ok: true, value: raw.trim() } : fail("expected an http, https, mailto or tel link");
+    case "list": {
+      if (typeof raw === "string") {
+        const entries = raw.split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean);
+        return { ok: true, value: entries };
+      }
+      if (Array.isArray(raw) && raw.every((entry) => typeof entry === "string" || typeof entry === "number" && Number.isFinite(entry))) {
+        return { ok: true, value: raw.map(String) };
+      }
+      return fail("expected a list of strings");
+    }
+  }
+}
+function isProvided(kind, raw) {
+  if (raw === void 0 || raw === null) return false;
+  if (typeof raw === "string" && raw.trim() === "" && kind !== "text") return false;
+  return true;
+}
+function variableDeclarations(presentation) {
+  if (!isRecord(presentation) || !isRecord(presentation.variables)) return [];
+  const out = [];
+  for (const [id, entry] of Object.entries(presentation.variables)) {
+    if (!idPattern.test(id)) continue;
+    const path = pathFor("/variables", id);
+    if (typeof entry === "string") {
+      if (hexPattern.test(entry)) out.push({ id, kind: "color", path, required: true, value: entry });
+      continue;
+    }
+    if (!isRecord(entry) || !isKind(entry.type)) continue;
+    const kind = entry.type;
+    const declaration = { id, kind, path, required: entry.required !== false };
+    const value = entry.value !== void 0 ? coerceVariableValue(kind, entry.value) : void 0;
+    if (value?.ok) declaration.value = value.value;
+    const example = entry.example !== void 0 ? coerceVariableValue(kind, entry.example) : void 0;
+    if (example?.ok) declaration.example = example.value;
+    if (typeof entry.format === "string") declaration.format = entry.format;
+    if (typeof entry.label === "string") declaration.label = entry.label;
+    if (typeof entry.description === "string") declaration.description = entry.description;
+    out.push(declaration);
+  }
+  return out;
+}
+function hasContentVariables(presentation) {
+  return isTemplate(presentation) || variableDeclarations(presentation).some((declaration) => declaration.kind !== "color");
+}
+var POSITIVE_ZERO = "0";
+function formatVariableNumber(value, pattern) {
+  if (!Number.isFinite(value)) return { error: `'${String(value)}' is not a finite number.` };
+  if (pattern === void 0 || pattern === "") return { text: String(value) };
+  const match = /^([^#0,.]*)((?:[#0,]*)(?:\.[#0]+)?)([\s\S]*)$/.exec(pattern);
+  const numeric = match?.[2] ?? "";
+  if (!match || !/[#0]/.test(numeric)) return { error: `Number format '${pattern}' needs a numeric part of '#' and '0' characters.` };
+  const prefix = match[1] ?? "";
+  const suffix = match[3] ?? "";
+  const [integerPattern = "", decimalPattern2 = ""] = numeric.split(".");
+  const grouping = integerPattern.includes(",");
+  const minInteger = [...integerPattern].filter((char) => char === "0").length;
+  const minDecimals = [...decimalPattern2].filter((char) => char === "0").length;
+  const maxDecimals = decimalPattern2.length;
+  const scaled = prefix.includes("%") || suffix.includes("%") ? value * 100 : value;
+  const absolute = Math.abs(scaled);
+  let fixed;
+  const shifted = Number(`${absolute}e${maxDecimals}`);
+  if (absolute >= 1e21) fixed = `${BigInt(absolute).toString()}${maxDecimals ? `.${"0".repeat(maxDecimals)}` : ""}`;
+  else if (/e/i.test(String(absolute)) || !Number.isSafeInteger(Math.round(shifted))) fixed = absolute.toFixed(maxDecimals);
+  else {
+    const digits = String(Math.round(shifted)).padStart(maxDecimals + 1, "0");
+    fixed = maxDecimals ? `${digits.slice(0, -maxDecimals)}.${digits.slice(-maxDecimals)}` : digits;
+  }
+  let [integer = POSITIVE_ZERO, decimals = ""] = fixed.split(".");
+  while (decimals.length > minDecimals && decimals.endsWith("0")) decimals = decimals.slice(0, -1);
+  integer = integer.replace(/^0+(?=\d)/, "");
+  if (integer === POSITIVE_ZERO && minInteger === 0 && decimals) integer = "";
+  integer = integer.padStart(minInteger, "0");
+  if (grouping) integer = integer.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  const body = `${integer}${decimals ? `.${decimals}` : ""}` || POSITIVE_ZERO;
+  const negative = scaled < 0 && /[1-9]/.test(body);
+  return { text: `${negative ? "-" : ""}${prefix}${body}${suffix}` };
+}
+function diag(context, entry, dedupeKey) {
+  if (dedupeKey) {
+    if (context.seen.has(dedupeKey)) return;
+    context.seen.add(dedupeKey);
+  }
+  context.diagnostics.push(entry);
+}
+function sampleValue(declaration) {
+  return declaration.example !== void 0 ? declaration.example : declaration.value !== void 0 ? declaration.value : SAMPLES[declaration.kind];
+}
+function plainText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map((run) => typeof run === "string" ? run : isRecord(run) && typeof run.text === "string" ? run.text : "").join("");
+  return "";
+}
+function inlineText(effective, format, path, context) {
+  const { declaration } = effective;
+  const value = effective.status === "unfilled" ? sampleValue(declaration) : effective.value;
+  switch (declaration.kind) {
+    case "color":
+    case "url":
+      return String(value);
+    case "text":
+      if (Array.isArray(value)) {
+        diag(context, { code: "variable-rich-flattened", severity: "info", path, id: declaration.id, message: `Rich text variable '${declaration.id}' is inserted as plain text inside a string; reference it whole as 'var:${declaration.id}' to keep its formatting.` }, `flat:${declaration.id}:${path}`);
+      }
+      return plainText(value);
+    case "number": {
+      const pattern = (format ?? declaration.format)?.trim();
+      const formatted = formatVariableNumber(value, pattern === "" ? void 0 : pattern);
+      if ("error" in formatted) {
+        diag(context, { code: "variable-format", severity: "error", path, id: declaration.id, message: formatted.error }, `fmt:${declaration.id}:${format ?? ""}`);
+        return String(value);
+      }
+      return formatted.text;
+    }
+    case "date": {
+      const pattern = (format ?? declaration.format)?.trim() || DEFAULT_VARIABLE_DATE_FORMAT;
+      const formatted = formatFurnitureDate(String(value), pattern);
+      if ("error" in formatted) {
+        diag(context, { code: "variable-format", severity: "error", path, id: declaration.id, message: formatted.error }, `fmt:${declaration.id}:${format ?? ""}`);
+        return String(value);
+      }
+      return formatted.text;
+    }
+    case "image":
+      return isRecord(value) ? String(value.src) : String(value);
+    case "list":
+      return value.join(format ?? ", ");
+  }
+}
+function interpolate(text, path, context) {
+  let changed = false;
+  const value = text.replace(tokenPattern, (match, id, format) => {
+    if (id === void 0) {
+      if (context.unescape) {
+        changed = true;
+        return "{{";
+      }
+      return match;
+    }
+    context.uses.push({ id, path, form: "token" });
+    const effective = context.effective.get(id);
+    if (!effective) {
+      diag(context, { code: "variable-unknown", severity: "warning", path, id, message: `'{{${id}}}' names no declared variable; declare '${id}' in the top-level variables map, or write '\\{{' for literal braces.` }, `unk:${id}:${path}`);
+      return match;
+    }
+    if (effective.status === "unfilled" && !context.shape) {
+      if (!effective.declaration.required) {
+        changed = true;
+        return "";
+      }
+      return match;
+    }
+    const result = inlineText(effective, effective.declaration.kind === "list" ? format : format?.trim(), path, context);
+    if (result === void 0) return match;
+    changed = true;
+    return result;
+  });
+  return { value, changed };
+}
+var OMIT = /* @__PURE__ */ Symbol("omit");
+var Splice = class {
+  constructor(values) {
+    this.values = values;
+  }
+  values;
+};
+function reduceString(text, path, parentIsArray, context) {
+  const reference = referencePattern.exec(text);
+  if (reference) {
+    const id = reference[1];
+    const effective = context.effective.get(id);
+    if (effective && effective.declaration.kind !== "color") {
+      context.uses.push({ id, path, form: "reference" });
+      if (effective.status === "unfilled" && !context.shape) {
+        return effective.declaration.required ? { kind: "keep" } : { kind: "omit" };
+      }
+      const value = effective.status === "unfilled" ? sampleValue(effective.declaration) : effective.value;
+      if (effective.declaration.kind === "list" && parentIsArray) {
+        return context.shape ? { kind: "replace", value: value[0] ?? "" } : { kind: "splice", values: clone(value) };
+      }
+      return { kind: "replace", value: clone(value) };
+    }
+    if (effective) {
+      context.uses.push({ id, path, form: "reference" });
+      return { kind: "keep" };
+    }
+    return { kind: "keep" };
+  }
+  if (!text.includes("{{")) return { kind: "keep" };
+  const result = interpolate(text, path, context);
+  return result.changed ? { kind: "replace", value: result.value } : { kind: "keep" };
+}
+var skippedKeys = /* @__PURE__ */ new Set(["extensions"]);
+var skippedRootKeys = /* @__PURE__ */ new Set(["variables", "catalogs", "$schema", "template"]);
+function walk(value, path, parentIsArray, context) {
+  if (typeof value === "string") {
+    const reduced = reduceString(value, path, parentIsArray, context);
+    if (reduced.kind === "keep") return value;
+    if (reduced.kind === "omit") return OMIT;
+    if (reduced.kind === "splice") return new Splice(reduced.values);
+    return reduced.value;
+  }
+  if (Array.isArray(value)) {
+    let changed = false;
+    const out = [];
+    value.forEach((entry, index) => {
+      const next = walk(entry, `${path}/${index}`, true, context);
+      if (next === OMIT) {
+        changed = true;
+        return;
+      }
+      if (next instanceof Splice) {
+        changed = true;
+        out.push(...next.values);
+        return;
+      }
+      if (next !== entry) changed = true;
+      out.push(next);
+    });
+    return changed ? out : value;
+  }
+  if (isRecord(value)) {
+    let changed = false;
+    const entries = [];
+    for (const [key, entry] of Object.entries(value)) {
+      if (skippedKeys.has(key) || path === "" && skippedRootKeys.has(key)) {
+        entries.push([key, entry]);
+        continue;
+      }
+      const next = walk(entry, pathFor(path || "/", key), false, context);
+      if (next === OMIT) {
+        changed = true;
+        continue;
+      }
+      if (next !== entry) changed = true;
+      entries.push([key, next]);
+    }
+    return changed ? Object.fromEntries(entries) : value;
+  }
+  return value;
+}
+function plan(presentation, values, options) {
+  const declarations = variableDeclarations(presentation);
+  const template = options.template ?? isTemplate(presentation);
+  const lenient = template || options.partial === true;
+  const context = {
+    effective: /* @__PURE__ */ new Map(),
+    diagnostics: [],
+    uses: [],
+    unescape: false,
+    shape: options.shape === true,
+    content: hasContentVariables(presentation) || template,
+    seen: /* @__PURE__ */ new Set()
+  };
+  const unfilled = [];
+  const examplesUsed = [];
+  const providedColors = /* @__PURE__ */ new Map();
+  const declared = new Set(declarations.map((declaration) => declaration.id));
+  for (const key of Object.keys(values)) {
+    if (!declared.has(key)) {
+      context.diagnostics.push({ code: "variable-unknown-value", severity: "warning", path: "/variables", id: key, message: `A value was supplied for '${key}', which no variable declares.` });
+    }
+  }
+  for (const declaration of declarations) {
+    const raw = hasOwn(values, declaration.id) ? values[declaration.id] : void 0;
+    let effective;
+    if (isProvided(declaration.kind, raw)) {
+      const coerced = coerceVariableValue(declaration.kind, raw);
+      if (coerced.ok) {
+        effective = { declaration, status: "filled", value: coerced.value, provided: true };
+        if (declaration.kind === "color") providedColors.set(declaration.id, coerced.value);
+      } else {
+        context.diagnostics.push({ code: "variable-invalid-value", severity: "error", path: declaration.path, id: declaration.id, message: `Value for '${declaration.id}' (${declaration.kind}): ${coerced.message}.` });
+      }
+    }
+    if (!effective && declaration.value !== void 0) effective = { declaration, status: "filled", value: declaration.value, provided: false };
+    if (!effective && options.examples && declaration.example !== void 0) {
+      effective = { declaration, status: "example", value: declaration.example, provided: false };
+      examplesUsed.push(declaration.id);
+      context.diagnostics.push({ code: "variable-example-used", severity: "info", path: declaration.path, id: declaration.id, message: `'${declaration.id}' is unfilled; its example is used.` });
+      if (declaration.kind === "color") providedColors.set(declaration.id, declaration.example);
+    }
+    if (!effective) {
+      effective = { declaration, status: "unfilled", provided: false };
+      if (declaration.required) {
+        unfilled.push(declaration.id);
+        context.diagnostics.push({
+          code: "variable-unfilled",
+          severity: lenient ? "info" : "error",
+          path: declaration.path,
+          id: declaration.id,
+          message: lenient ? `'${declaration.id}' (${declaration.kind}) is not filled yet.` : `Required variable '${declaration.id}' (${declaration.kind}) has no value. Provide one, or mark the document as a template ("template": true).`
+        });
+      }
+    }
+    context.effective.set(declaration.id, effective);
+  }
+  return { context, declarations, unfilled, examplesUsed, providedColors };
+}
+function rebuildVariables(presentation, built, keepAll) {
+  const source = presentation.variables;
+  if (!isRecord(source)) return void 0;
+  const out = [];
+  for (const [id, entry] of Object.entries(source)) {
+    const effective = built.context.effective.get(id);
+    if (!effective) {
+      out.push([id, entry]);
+      continue;
+    }
+    const { declaration } = effective;
+    if (declaration.kind !== "color") {
+      if (keepAll || effective.status === "unfilled" && declaration.required) out.push([id, entry]);
+      continue;
+    }
+    const color = built.providedColors.get(id);
+    if (color === void 0) {
+      out.push([id, entry]);
+      continue;
+    }
+    const base = isRecord(entry) ? entry : {};
+    const { example: _example, required: _required, label: _label, ...rest } = base;
+    out.push([id, { ...rest, type: "color", value: color }]);
+  }
+  return out.length ? Object.fromEntries(out) : void 0;
+}
+function finish(presentation, built, options) {
+  const { context } = built;
+  const complete = built.unfilled.length === 0;
+  context.unescape = complete && context.content && !context.shape;
+  const walked = context.content ? walk(presentation, "", false, context) : presentation;
+  const result = { ...walked };
+  const variables = rebuildVariables(presentation, built, context.shape);
+  if (variables) result.variables = variables;
+  else delete result.variables;
+  if (!context.shape && complete && hasOwn(result, "template")) delete result.template;
+  if (context.content) {
+    const used = new Set(context.uses.map((use) => use.id));
+    for (const declaration of built.declarations) {
+      if (declaration.kind !== "color" && !used.has(declaration.id)) {
+        context.diagnostics.push({ code: "variable-unused", severity: "warning", path: declaration.path, id: declaration.id, message: `Variable '${declaration.id}' is declared but never used; reference it as '{{${declaration.id}}}' or 'var:${declaration.id}'.` });
+      }
+    }
+  }
+  const diagnostics = context.diagnostics;
+  if (options.strict && diagnostics.some((entry) => entry.severity === "error")) throw new OPFVariableError(diagnostics);
+  return { presentation: result, diagnostics, unfilled: built.unfilled, examplesUsed: built.examplesUsed, complete };
+}
+function resolveVariables(presentation, values = {}, options = {}) {
+  if (!isRecord(presentation)) throw new TypeError("resolveVariables expects a presentation object.");
+  if (!isRecord(values)) throw new TypeError("resolveVariables values must be an object keyed by variable id.");
+  const built = plan(presentation, values, options);
+  if (!built.context.content && built.providedColors.size === 0 && built.context.diagnostics.length === 0) {
+    return { presentation, diagnostics: [], unfilled: built.unfilled, examplesUsed: [], complete: built.unfilled.length === 0 };
+  }
+  return finish(presentation, built, options);
+}
+function instantiateForValidation(presentation, values = {}, template) {
+  const options = { template, shape: true, partial: true };
+  return finish(presentation, plan(presentation, values, options), options);
+}
+function listVariables(presentation, values = {}) {
+  if (!isRecord(presentation)) return [];
+  const built = plan(presentation, isRecord(values) ? values : {}, { examples: false, partial: true });
+  built.context.shape = true;
+  built.context.content = true;
+  walk(presentation, "", false, built.context);
+  return built.declarations.map((declaration) => {
+    const effective = built.context.effective.get(declaration.id);
+    return {
+      ...declaration,
+      ...effective?.status === "filled" && effective.provided ? { value: effective.value } : {},
+      filled: effective?.status === "filled",
+      uses: built.context.uses.filter((use) => use.id === declaration.id)
+    };
+  });
+}
+
+// src/validator.ts
+var OPFValidationError = class extends Error {
+  issues;
+  result;
+  constructor(result) {
+    const first = result.errors[0];
+    super(first ? `OPF validation failed at ${first.path}: ${first.message}` : "OPF validation failed");
+    this.name = "OPFValidationError";
+    this.issues = result.errors;
+    this.result = result;
+  }
+};
+var schemaNameByCatalogKind = catalogSchemaNames;
+var ajv;
+var dynamicSchemaCache = /* @__PURE__ */ new WeakMap();
+var promotedRegionKeySet = new Set(promotedRegionKeys);
+var rootPayloadFields = [
+  "type",
+  "text",
+  "items",
+  "bullets",
+  "image",
+  "video",
+  "chart",
+  "table",
+  "code",
+  "metric",
+  "quote",
+  "timeline",
+  "blocks"
+];
+var contentKindSpecs = {
+  text: {
+    fields: ["text", "bullets"],
+    required: [],
+    requireAny: ["text", "bullets"]
+  },
+  list: {
+    fields: ["items"],
+    required: ["items"]
+  },
+  image: {
+    fields: ["image"],
+    required: ["image"]
+  },
+  chart: {
+    fields: ["chart"],
+    required: ["chart"]
+  },
+  table: {
+    fields: ["table"],
+    required: ["table"]
+  },
+  video: {
+    fields: ["video"],
+    required: ["video"]
+  },
+  code: {
+    fields: ["code"],
+    required: ["code"]
+  },
+  metric: {
+    fields: ["metric"],
+    required: ["metric"]
+  },
+  quote: {
+    fields: ["quote"],
+    required: ["quote"]
+  },
+  timeline: {
+    fields: ["timeline"],
+    required: ["timeline"]
+  }
+};
+var captionableKinds = /* @__PURE__ */ new Set(["image", "chart", "table", "video"]);
+var columnSpans = {
+  left: [0],
+  center: [1],
+  right: [2],
+  "left+center": [0, 1],
+  "center+right": [1, 2],
+  "left+center+right": [0, 1, 2]
+};
+var rowSpans = {
+  top: [0],
+  middle: [1],
+  bottom: [2],
+  "top+middle": [0, 1],
+  "middle+bottom": [1, 2],
+  "top+middle+bottom": [0, 1, 2]
+};
+function getAjv() {
+  if (ajv) {
+    return ajv;
+  }
+  const instance = new Ajv2020({
+    allErrors: true,
+    verbose: true,
+    strict: false,
+    allowUnionTypes: true
+  });
+  addFormats(instance);
+  for (const schema of Object.values(schemas)) {
+    instance.addSchema(schema);
+  }
+  ajv = instance;
+  return instance;
+}
+function isSchemaName(value) {
+  return typeof value === "string" && value in schemas;
+}
+function isCatalogKind(value) {
+  return typeof value === "string" && value in schemaNameByCatalogKind;
+}
+function resolveValidator(schemaOrKind) {
+  const instance = getAjv();
+  if (isSchemaName(schemaOrKind)) {
+    const schema = schemas[schemaOrKind];
+    const validator2 = instance.getSchema(schema.$id) ?? instance.compile(schema);
+    return { validate: validator2, schemaName: schemaOrKind };
+  }
+  if (isCatalogKind(schemaOrKind)) {
+    const schemaName = schemaNameByCatalogKind[schemaOrKind];
+    const schema = schemas[schemaName];
+    const validator2 = instance.getSchema(schema.$id) ?? instance.compile(schema);
+    return { validate: validator2, schemaName, catalogKind: schemaOrKind };
+  }
+  const cached = dynamicSchemaCache.get(schemaOrKind);
+  if (cached) {
+    return { validate: cached };
+  }
+  const validator = instance.compile(schemaOrKind);
+  dynamicSchemaCache.set(schemaOrKind, validator);
+  return { validate: validator };
+}
+function toIssue(error) {
+  const issue2 = {
+    path: error.instancePath || "/",
+    message: error.message ?? "failed validation",
+    keyword: error.keyword,
+    schemaPath: error.schemaPath,
+    params: error.params
+  };
+  rememberValidationDefinition(issue2, error.parentSchema, error.keyword);
+  return issue2;
+}
+function semanticIssue(path, message, params = {}) {
+  return {
+    path,
+    message,
+    keyword: "opf",
+    schemaPath: "#/x-opf-semantics",
+    params
+  };
+}
+function hasOwn2(value, key) {
+  return Object.hasOwn(value, key);
+}
+function isEnUkTag(value) {
+  return typeof value === "string" && value.toLowerCase() === "en-uk";
+}
+function presentFields(value, fields) {
+  return fields.filter((field) => hasOwn2(value, field));
+}
+function isContentKind(value) {
+  return typeof value === "string" && value in contentKindSpecs;
+}
+function inferredKinds(value) {
+  const kinds = [];
+  if (presentFields(value, contentKindSpecs.text.fields).length > 0) kinds.push("text");
+  if (hasOwn2(value, "items")) kinds.push("list");
+  if (hasOwn2(value, "image")) kinds.push("image");
+  if (hasOwn2(value, "video")) kinds.push("video");
+  if (hasOwn2(value, "chart")) kinds.push("chart");
+  if (hasOwn2(value, "table")) kinds.push("table");
+  if (hasOwn2(value, "code")) kinds.push("code");
+  if (hasOwn2(value, "metric")) kinds.push("metric");
+  if (hasOwn2(value, "quote")) kinds.push("quote");
+  if (hasOwn2(value, "timeline")) kinds.push("timeline");
+  return kinds;
+}
+function isImplicitBlocksComposition(value, inferred, options) {
+  if (options.slideRoot !== true || hasOwn2(value, "blocks")) {
+    return false;
+  }
+  return inferred.length > 1;
+}
+function validateContentPayload(value, path, options = {}) {
+  const issues = [];
+  const explicitType = value.type;
+  const payloadFields = presentFields(value, rootPayloadFields);
+  const hasBlocks = hasOwn2(value, "blocks");
+  const captionIssue = (reason, params = {}) => semanticIssue(pathFor(path, "caption"), `caption is only valid on an image, chart, table or video payload; ${reason}`, { code: "caption-unsupported-payload", ...params });
+  if (hasBlocks || explicitType === "group") {
+    if (hasOwn2(value, "caption")) issues.push(captionIssue("a group cannot carry one"));
+    if (explicitType !== void 0 && explicitType !== "group") issues.push(semanticIssue(path, "a group must use type 'group' or omit type"));
+    const incompatible2 = payloadFields.filter((field) => field !== "blocks" && field !== "type");
+    if (incompatible2.length) issues.push(semanticIssue(path, "blocks cannot be mixed with leaf payload fields", { fields: incompatible2 }));
+    if (!Array.isArray(value.blocks) || value.blocks.length === 0 && !options.slideRoot) issues.push(semanticIssue(pathFor(path, "blocks"), "a group requires at least one block"));
+    if (Array.isArray(value.blocks)) value.blocks.forEach((block, index) => {
+      if (isRecord(block)) issues.push(...validateContentPayload(block, `${pathFor(path, "blocks")}/${index}`));
+    });
+    return issues;
+  }
+  if (hasOwn2(value, "composition") && !options.slideRoot) issues.push(semanticIssue(pathFor(path, "composition"), "composition is only valid on a group containing blocks"));
+  if (explicitType !== void 0 && !isContentKind(explicitType)) {
+    return issues;
+  }
+  const kind = isContentKind(explicitType) ? explicitType : void 0;
+  const inferred = kind ? [kind] : inferredKinds(value);
+  if (!kind && inferred.length === 0) {
+    if (payloadFields.length > 0 || path !== "/") {
+      issues.push(semanticIssue(path, "content payload must include concrete content fields", {
+        fields: payloadFields
+      }));
+    }
+    return issues;
+  }
+  if (!kind && inferred.length > 1) {
+    if (isImplicitBlocksComposition(value, inferred, options)) {
+      if (hasOwn2(value, "caption")) issues.push(captionIssue("a slide root with several payloads cannot carry one; put the caption on a block", { inferredTypes: inferred }));
+      return issues;
+    }
+    issues.push(semanticIssue(path, "content payload mixes fields from incompatible content types", {
+      inferredTypes: inferred
+    }));
+    return issues;
+  }
+  const resolvedKind = inferred[0];
+  if (!resolvedKind) {
+    return issues;
+  }
+  const spec = contentKindSpecs[resolvedKind];
+  if (hasOwn2(value, "caption") && !captionableKinds.has(resolvedKind)) issues.push(captionIssue(`this payload is '${resolvedKind}'`, { type: resolvedKind }));
+  const allowedFields = /* @__PURE__ */ new Set([
+    "type",
+    ...spec.fields
+  ]);
+  for (const required of spec.required) {
+    if (!hasOwn2(value, required)) {
+      issues.push(semanticIssue(path, `content payload type '${resolvedKind}' requires '${required}'`, {
+        type: resolvedKind,
+        required
+      }));
+    }
+  }
+  if (spec.requireAny && presentFields(value, spec.requireAny).length === 0) {
+    issues.push(semanticIssue(path, `content payload type '${resolvedKind}' requires one of: ${spec.requireAny.join(", ")}`, {
+      type: resolvedKind,
+      requiredAny: spec.requireAny
+    }));
+  }
+  const incompatible = payloadFields.filter((field) => !allowedFields.has(field));
+  if (incompatible.length > 0) {
+    issues.push(semanticIssue(path, `content payload type '${resolvedKind}' cannot include incompatible fields: ${incompatible.join(", ")}`, {
+      type: resolvedKind,
+      incompatible
+    }));
+  }
+  return issues;
+}
+function slideRegion(key) {
+  if (key.includes(":")) {
+    const [rowPart, columnPart] = key.split(":");
+    if (!rowPart || !columnPart) return void 0;
+    const rows = rowSpans[rowPart];
+    const columns = columnSpans[columnPart];
+    return rows && columns ? { rows, columns } : void 0;
+  }
+  if (key in columnSpans) {
+    const columns = columnSpans[key];
+    return columns ? { rows: [0, 1, 2], columns } : void 0;
+  }
+  if (key in rowSpans) {
+    const rows = rowSpans[key];
+    return rows ? { rows, columns: [0, 1, 2] } : void 0;
+  }
+  return void 0;
+}
+function intersects(left, right) {
+  return left.some((value) => right.includes(value));
+}
+function regionsOverlap(left, right) {
+  return intersects(left.rows, right.rows) && intersects(left.columns, right.columns);
+}
+function validateSlideRegions(slide, slidePath) {
+  const issues = [];
+  const regionKeys = Object.keys(slide).filter((key) => promotedRegionKeySet.has(key));
+  const rootFields = presentFields(slide, rootPayloadFields);
+  if (regionKeys.length > 0 && rootFields.length > 0) {
+    issues.push(semanticIssue(slidePath, "root content payload fields cannot be mixed with promoted region keys", {
+      rootFields,
+      regionKeys
+    }));
+  }
+  if (regionKeys.length === 0 && rootFields.length > 0) {
+    issues.push(...validateContentPayload(slide, slidePath, { slideRoot: true }));
+  }
+  for (const key of regionKeys) {
+    const value = slide[key];
+    if (isRecord(value)) {
+      issues.push(...validateContentPayload(value, pathFor(slidePath, key)));
+    }
+  }
+  for (let leftIndex = 0; leftIndex < regionKeys.length; leftIndex += 1) {
+    const leftKey = regionKeys[leftIndex];
+    if (!leftKey) continue;
+    const leftRegion = slideRegion(leftKey);
+    if (!leftRegion) continue;
+    for (let rightIndex = leftIndex + 1; rightIndex < regionKeys.length; rightIndex += 1) {
+      const rightKey = regionKeys[rightIndex];
+      if (!rightKey) continue;
+      const rightRegion = slideRegion(rightKey);
+      if (!rightRegion) continue;
+      if (regionsOverlap(leftRegion, rightRegion)) {
+        issues.push(semanticIssue(slidePath, `promoted region keys '${leftKey}' and '${rightKey}' overlap`, {
+          regionKeys: [leftKey, rightKey]
+        }));
+      }
+    }
+  }
+  return issues;
+}
+function validatePresentationSemantics(value) {
+  if (!isRecord(value) || !Array.isArray(value.slides)) {
+    return [];
+  }
+  const issues = [];
+  if (isEnUkTag(value.language)) {
+    issues.push(semanticIssue("/language", "Use 'en-GB' for UK English; 'en-UK' is not a valid BCP-47 region tag", {
+      replacement: "en-GB"
+    }));
+  } else if (isRecord(value.language) && isEnUkTag(value.language.bcp47)) {
+    issues.push(semanticIssue("/language/bcp47", "Use 'en-GB' for UK English; 'en-UK' is not a valid BCP-47 region tag", {
+      replacement: "en-GB"
+    }));
+  }
+  const documentIds = /* @__PURE__ */ new Map();
+  value.slides.forEach((slide, index) => {
+    if (isRecord(slide)) {
+      const slidePath = `/slides/${index}`;
+      if (typeof slide.id === "string") {
+        const seen = documentIds.get(slide.id);
+        if (seen === "slide") issues.push(semanticIssue(`${slidePath}/id`, "slide ids must be unique within a presentation", { id: slide.id }));
+        else if (seen === "payload") issues.push(semanticIssue(`${slidePath}/id`, "slide id duplicates a content payload id; ids must be unique among slide and payload ids within a presentation", { id: slide.id }));
+        else documentIds.set(slide.id, "slide");
+      }
+      visitContentPayloads(slide, slidePath, (payload, path) => {
+        if (typeof payload.id === "string") {
+          if (documentIds.has(payload.id)) issues.push(semanticIssue(`${path}/id`, "content payload ids must be unique among slide and payload ids within a presentation", { id: payload.id }));
+          else documentIds.set(payload.id, "payload");
+        }
+      });
+      issues.push(...validateSlideRegions(slide, slidePath));
+      const payloadTableIssues = (payload, path) => {
+        if (isRecord(payload.table)) for (const issue2 of tableGrid(payload.table).issues) issues.push(semanticIssue(pathFor(path, "table") + issue2.path.slice(5).replaceAll(".", "/"), issue2.message));
+      };
+      payloadTableIssues(slide, slidePath);
+      visitContentPayloads(slide, slidePath, payloadTableIssues);
+      const payloadNumberingIssues = (payload, path) => {
+        for (const finding of numberingFindings(payload).errors) issues.push(semanticIssue(pathFor(path, finding.key), finding.message, finding.params));
+      };
+      payloadNumberingIssues(slide, slidePath);
+      visitContentPayloads(slide, slidePath, payloadNumberingIssues);
+    }
+  });
+  issues.push(...annotationIssues(value));
+  return issues;
+}
+function inlineCatalogEntry(context, kind) {
+  const catalogsField = context.document.catalogs;
+  if (!isRecord(catalogsField)) {
+    return void 0;
+  }
+  const entry = catalogsField[kind];
+  return isRecord(entry) ? entry : void 0;
+}
+function unknownIdWarning(kind, value, path, context) {
+  if (typeof value !== "string" || !bareIdPattern.test(value)) {
+    return void 0;
+  }
+  if (context) {
+    const entry = inlineCatalogEntry(context, kind);
+    if (entry) {
+      const inline = Array.isArray(entry.records) ? entry.records.find((record) => isRecord(record) && record.id === value) : void 0;
+      if (isRecord(inline)) {
+        const replacedBy = isRecord(inline.deprecation) ? inline.deprecation.replacedBy : void 0;
+        return typeof replacedBy === "string" ? deprecatedIdWarning(kind, value, replacedBy, path) : void 0;
+      }
+      if (typeof entry.source === "string" || Array.isArray(entry.source) && entry.source.length > 0) {
+        return void 0;
+      }
+    }
+  }
+  if (catalogIds[kind].includes(value)) {
+    const replacedBy = deprecatedCatalogIds[`${kind}/${value}`];
+    return replacedBy === void 0 ? void 0 : deprecatedIdWarning(kind, value, replacedBy, path);
+  }
+  return semanticIssue(path, `unknown ${kind} catalog id '${value}'`, { kind, id: value });
+}
+function deprecatedIdWarning(kind, id, replacedBy, path) {
+  return semanticIssue(path, `deprecated ${kind} catalog id '${id}'; use '${replacedBy}'`, { kind, id, replacedBy });
+}
+function referenceObjectWarning(kind, value, path, context) {
+  if (typeof value === "string") {
+    return unknownIdWarning(kind, value, path, context);
+  }
+  if (isRecord(value)) {
+    return unknownIdWarning(kind, value.id, pathFor(path, "id"), context);
+  }
+  return void 0;
+}
+function pushIfDefined(issues, issue2) {
+  if (issue2) {
+    issues.push(issue2);
+  }
+}
+function designReferenceWarnings(design, path, context) {
+  if (!isRecord(design)) {
+    return [];
+  }
+  const issues = [];
+  pushIfDefined(issues, referenceObjectWarning("themes", design.theme, pathFor(path, "theme"), context));
+  pushIfDefined(issues, referenceObjectWarning("colorSchemes", design.colorScheme, pathFor(path, "colorScheme"), context));
+  pushIfDefined(issues, referenceObjectWarning("fontSchemes", design.fontScheme, pathFor(path, "fontScheme"), context));
+  if (isRecord(design.theme)) {
+    const themePath = pathFor(path, "theme");
+    pushIfDefined(issues, referenceObjectWarning("colorSchemes", design.theme.colorScheme, pathFor(themePath, "colorScheme"), context));
+    pushIfDefined(issues, referenceObjectWarning("fontSchemes", design.theme.fontScheme, pathFor(themePath, "fontScheme"), context));
+  }
+  return issues;
+}
+function chartTypeWarnings(payload, path, context) {
+  if (!isRecord(payload)) {
+    return [];
+  }
+  const issues = [];
+  if (isRecord(payload.chart)) {
+    pushIfDefined(issues, unknownIdWarning("chartTypes", payload.chart.type, `${pathFor(path, "chart")}/type`, context));
+    for (const diagnostic of resolveChartOptions(payload.chart, chartOptionTarget(payload.chart.type)).diagnostics) {
+      issues.push(semanticIssue(diagnostic.option.split(".").reduce(pathFor, pathFor(path, "chart")), diagnostic.message, { code: diagnostic.code, option: diagnostic.option, reason: diagnostic.reason }));
+    }
+  }
+  if (Array.isArray(payload.blocks)) {
+    payload.blocks.forEach((block, index) => {
+      issues.push(...chartTypeWarnings(block, `${pathFor(path, "blocks")}/${index}`, context));
+    });
+  }
+  return issues;
+}
+var cellBorderEdges = ["top", "right", "bottom", "left"];
+var variableIdPattern = /^[a-z][a-z0-9-]*$/;
+var hexColorPattern = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var schemeColorNames = /* @__PURE__ */ new Set([
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "dark1",
+  "dark2",
+  "light1",
+  "light2",
+  "hyperlink",
+  "followedHyperlink",
+  "primary",
+  "secondary",
+  "accent",
+  "background",
+  "surface",
+  "text",
+  "textSecondary"
+]);
+function variableReferenceWarnings(value) {
+  if (!Array.isArray(value.slides)) {
+    return [];
+  }
+  const variables = isRecord(value.variables) ? value.variables : {};
+  const issues = [];
+  const colorRef = (entry, path) => {
+    if (typeof entry !== "string" || !entry.startsWith("var:")) return;
+    const id = entry.slice("var:".length);
+    if (!variableIdPattern.test(id) || hasOwn2(variables, id)) return;
+    issues.push(semanticIssue(path, `unknown variable '${id}'; declare it in the top-level variables map`, { id }));
+  };
+  const runColor = (entry, path) => {
+    if (typeof entry !== "string") return;
+    if (hexColorPattern.test(entry) || schemeColorNames.has(entry)) return;
+    if (entry.startsWith("var:") && variableIdPattern.test(entry.slice("var:".length))) {
+      colorRef(entry, path);
+      return;
+    }
+    issues.push(semanticIssue(
+      path,
+      `run color '${entry}' is not a hex color, a color-scheme name, or a 'var:' reference; renderers fall back to the theme color`,
+      { color: entry }
+    ));
+  };
+  const richText = (entry, path) => {
+    if (!Array.isArray(entry)) return;
+    entry.forEach((run, index) => {
+      if (isRecord(run)) runColor(run.color, `${path}/${index}/color`);
+    });
+  };
+  const cellStyle = (style, path) => {
+    if (!isRecord(style)) return;
+    colorRef(style.fill, pathFor(path, "fill"));
+    colorRef(style.color, pathFor(path, "color"));
+    if (!isRecord(style.borders)) return;
+    const bordersPath = pathFor(path, "borders");
+    for (const edge of cellBorderEdges) {
+      const border = style.borders[edge];
+      if (isRecord(border)) colorRef(border.color, `${pathFor(bordersPath, edge)}/color`);
+    }
+  };
+  const tableCell = (cell, path) => {
+    if (Array.isArray(cell)) {
+      richText(cell, path);
+      return;
+    }
+    if (!isRecord(cell)) return;
+    richText(cell.value, pathFor(path, "value"));
+    cellStyle(cell.style, pathFor(path, "style"));
+  };
+  const table = (node, path) => {
+    if (!isRecord(node)) return;
+    if (Array.isArray(node.columns)) {
+      const columnsPath = pathFor(path, "columns");
+      node.columns.forEach((column, index) => {
+        tableCell(column, `${columnsPath}/${index}`);
+      });
+    }
+    if (Array.isArray(node.rows)) {
+      const rowsPath = pathFor(path, "rows");
+      node.rows.forEach((row, rowIndex) => {
+        if (!Array.isArray(row)) return;
+        row.forEach((cell, cellIndex) => {
+          tableCell(cell, `${rowsPath}/${rowIndex}/${cellIndex}`);
+        });
+      });
+    }
+  };
+  const textEntries = (entries, path) => {
+    if (!Array.isArray(entries)) return;
+    entries.forEach((entry, index) => {
+      const entryPath = `${path}/${index}`;
+      if (Array.isArray(entry)) {
+        richText(entry, entryPath);
+        return;
+      }
+      if (!isRecord(entry)) return;
+      richText(entry.text, pathFor(entryPath, "text"));
+      richText(entry.description, pathFor(entryPath, "description"));
+    });
+  };
+  const payload = (node, path) => {
+    richText(node.text, pathFor(path, "text"));
+    textEntries(node.items, pathFor(path, "items"));
+    textEntries(node.bullets, pathFor(path, "bullets"));
+    table(node.table, pathFor(path, "table"));
+  };
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    const slidePath = `/slides/${index}`;
+    payload(slide, slidePath);
+    visitContentPayloads(slide, slidePath, payload);
+  });
+  return issues;
+}
+function presentationReferenceWarnings(value) {
+  if (!isRecord(value) || !Array.isArray(value.slides)) {
+    return [];
+  }
+  const context = { document: value };
+  const issues = [];
+  if (typeof value.narrative === "string") {
+    pushIfDefined(issues, unknownIdWarning("narratives", value.narrative, "/narrative", context));
+  }
+  if (Array.isArray(value.audience)) {
+    value.audience.forEach((entry, index) => {
+      pushIfDefined(issues, referenceObjectWarning("audiences", entry, `/audience/${index}`, context));
+    });
+  } else {
+    pushIfDefined(issues, unknownIdWarning("audiences", value.audience, "/audience", context));
+  }
+  issues.push(...designReferenceWarnings(value.design, "/design", context));
+  issues.push(...variableReferenceWarnings(value));
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) {
+      return;
+    }
+    const slidePath = `/slides/${index}`;
+    issues.push(...designReferenceWarnings(slide.design, pathFor(slidePath, "design"), context));
+    issues.push(...chartTypeWarnings(slide, slidePath, context));
+    const numberingWarnings = (payload, path) => {
+      for (const finding of numberingFindings(payload).warnings) issues.push(semanticIssue(pathFor(path, finding.key), finding.message, finding.params));
+    };
+    numberingWarnings(slide, slidePath);
+    visitContentPayloads(slide, slidePath, numberingWarnings);
+    for (const key of Object.keys(slide)) {
+      if (promotedRegionKeySet.has(key)) {
+        issues.push(...chartTypeWarnings(slide[key], pathFor(slidePath, key), context));
+      }
+    }
+  });
+  return issues;
+}
+var catalogCrossLinkFields = {
+  audience: { recommendedNarratives: "narratives", recommendedTones: "tones" },
+  purpose: { recommendedNarratives: "narratives", recommendedTones: "tones" },
+  tone: { recommendedNarratives: "narratives" }
+};
+function catalogCrossLinkWarnings(schemaName, value) {
+  const fields = catalogCrossLinkFields[schemaName];
+  if (!fields || !isRecord(value)) {
+    return [];
+  }
+  const issues = [];
+  for (const [field, kind] of Object.entries(fields)) {
+    const links = value[field];
+    if (!Array.isArray(links)) {
+      continue;
+    }
+    links.forEach((link, index) => {
+      pushIfDefined(issues, unknownIdWarning(kind, link, `${pathFor("/", field)}/${index}`));
+    });
+  }
+  return issues;
+}
+function validateLanguageSemantics(value) {
+  if (!isRecord(value)) {
+    return [];
+  }
+  if (isEnUkTag(value.bcp47)) {
+    return [semanticIssue("/bcp47", "Use 'en-GB' for UK English; 'en-UK' is not a valid BCP-47 region tag", {
+      replacement: "en-GB"
+    })];
+  }
+  return [];
+}
+function contentDepthIssues(value) {
+  if (!isRecord(value) || !Array.isArray(value.slides)) return [];
+  const stack = [];
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    if (Array.isArray(slide.blocks)) slide.blocks.forEach((block, i) => {
+      stack.push({ value: block, path: `/slides/${index}/blocks/${i}`, depth: 0, ancestors: [] });
+    });
+    for (const key of promotedRegionKeys) if (hasOwn2(slide, key)) stack.push({ value: slide[key], path: `/slides/${index}/${key}`, depth: 0, ancestors: [] });
+  });
+  while (stack.length) {
+    const entry = stack.pop();
+    if (!isRecord(entry.value) || !Array.isArray(entry.value.blocks)) continue;
+    if (entry.ancestors.includes(entry.value) || entry.depth >= MAX_COMPOSITION_DEPTH) return [semanticIssue(entry.path, `content groups must be acyclic and nest at most ${MAX_COMPOSITION_DEPTH} levels`)];
+    const ancestors = [...entry.ancestors, entry.value];
+    entry.value.blocks.forEach((block, i) => {
+      stack.push({ value: block, path: `${entry.path}/blocks/${i}`, depth: entry.depth + 1, ancestors });
+    });
+  }
+  return [];
+}
+var variableTypeList = VARIABLE_KINDS.join(", ");
+function variableIssue(id, suffix, keyword, message, params) {
+  return {
+    instancePath: `/variables/${id.replaceAll("~", "~0").replaceAll("/", "~1")}${suffix}`,
+    schemaPath: "#/$defs/Variable/oneOf",
+    keyword,
+    params,
+    message
+  };
+}
+function typedVariableErrors(errors, value) {
+  if (!isRecord(value) || !isRecord(value.variables)) return errors;
+  if (!errors.some((error) => error.instancePath.startsWith("/variables/"))) return errors;
+  const variables = value.variables;
+  const kept = errors.filter((error) => !error.instancePath.startsWith("/variables/"));
+  const schemaId = schemas.presentation.$id;
+  for (const [id, entry] of Object.entries(variables)) {
+    if (typeof entry === "string") {
+      if (!hexColorPattern.test(entry)) kept.push(variableIssue(id, "", "type", "must be a hex color string or a variable object", {}));
+      continue;
+    }
+    if (!isRecord(entry)) {
+      kept.push(variableIssue(id, "", "type", "must be a hex color string or a variable object", {}));
+      continue;
+    }
+    const kind = entry.type;
+    if (typeof kind !== "string" || !VARIABLE_KINDS.includes(kind)) {
+      kept.push(variableIssue(id, "/type", "enum", `must be one of: ${variableTypeList} (a hex string is shorthand for a color variable)`, { allowedValues: [...VARIABLE_KINDS] }));
+      continue;
+    }
+    const definition = `${kind.charAt(0).toUpperCase()}${kind.slice(1)}Variable`;
+    const check = getAjv().getSchema(`${schemaId}#/$defs/${definition}`);
+    if (!check || check(entry) === true) continue;
+    for (const error of check.errors ?? []) {
+      kept.push({ ...error, instancePath: `/variables/${id.replaceAll("~", "~0").replaceAll("/", "~1")}${error.instancePath}`, schemaPath: `#/$defs/${definition}${error.schemaPath.replace(/^#/, "")}` });
+    }
+  }
+  return kept;
+}
+function validate(value, schemaOrKind = "presentation", options = {}) {
+  const resolved = resolveValidator(schemaOrKind);
+  if (resolved.schemaName === "presentation") {
+    const errors2 = contentDepthIssues(value);
+    if (errors2.length) return { valid: false, errors: errors2, warnings: [], schemaName: resolved.schemaName };
+  }
+  const variableIssues = { errors: [], warnings: [] };
+  let subject = value;
+  let template;
+  let unfilledVariables;
+  if (resolved.schemaName === "presentation" && isRecord(value) && (hasContentVariables(value) || options.values !== void 0 || options.template !== void 0)) {
+    template = options.template ?? isTemplate(value);
+    const view = instantiateForValidation(value, options.values ?? {}, template);
+    subject = view.presentation;
+    unfilledVariables = view.unfilled;
+    for (const entry of view.diagnostics) {
+      if (entry.code === "variable-example-used" || entry.code === "variable-rich-flattened" || entry.code === "variable-unfilled") continue;
+      const issue2 = semanticIssue(entry.path, entry.message, { id: entry.id, code: entry.code });
+      (entry.severity === "error" ? variableIssues.errors : variableIssues.warnings).push(issue2);
+    }
+    if (!template) {
+      const declared = isRecord(value.variables) ? value.variables : {};
+      for (const id of view.unfilled) {
+        if (isRecord(declared[id]) && declared[id].value !== void 0) continue;
+        variableIssues.errors.push(semanticIssue(`/variables/${id}`, `required variable '${id}' has no value; give it a value, fill it before use, or mark the document as a template ("template": true)`, { id, code: "variable-unfilled" }));
+      }
+    }
+  }
+  const valid = resolved.validate(subject) === true;
+  const errors = valid ? [] : typedVariableErrors(resolved.validate.errors ?? [], subject).map(toIssue);
+  const warnings = [];
+  if (resolved.schemaName === "presentation") {
+    errors.push(...validatePresentationSemantics(subject));
+    errors.push(...variableIssues.errors);
+    warnings.push(...presentationReferenceWarnings(subject));
+    warnings.push(...variableIssues.warnings);
+  } else if (resolved.schemaName === "language") {
+    errors.push(...validateLanguageSemantics(value));
+  }
+  if (resolved.schemaName) {
+    warnings.push(...catalogCrossLinkWarnings(resolved.schemaName, value));
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    schemaName: resolved.schemaName,
+    catalogKind: resolved.catalogKind,
+    ...template !== void 0 ? { template, unfilledVariables } : {}
+  };
+}
+function assertValid(value, schemaOrKind = "presentation", options = {}) {
+  const result = validate(value, schemaOrKind, options);
+  if (!result.valid) {
+    throw new OPFValidationError(result);
+  }
+  return value;
+}
+function validatePresentation(value, options = {}) {
+  return validate(value, "presentation", options);
+}
+function assertValidPresentation(value, options = {}) {
+  assertValid(value, "presentation", options);
+}
+function validateCatalogRecord(kind, value) {
+  return validate(value, kind);
+}
+function assertValidCatalogRecord(kind, value) {
+  assertValid(value, kind);
+}
+
+export { DEFAULT_VARIABLE_DATE_FORMAT, OPFValidationError, OPFVariableError, VARIABLE_KINDS, assertValid, assertValidCatalogRecord, assertValidPresentation, coerceVariableValue, formatVariableNumber, hasContentVariables, isTemplate, listVariables, resolveVariables, unusedReferenceWarnings, validate, validateCatalogRecord, validatePresentation, validationDefinition, variableDeclarations };