@openpresentation/opf 0.13.0 → 0.15.1

package/dist/chunk-IYCJUKWD.js

@@ -1,951 +0,0 @@
-import { promotedRegionKeys, VARIABLE_KINDS, isRecord, collectCitations, hasContentVariables, isTemplate, instantiateForValidation, MAX_COMPOSITION_DEPTH, visitContentPayloads, datasetDiagnostics, pathFor, tableGrid, numberingFindings, walkCitationRuns, resolveChartData, resolveTableData, bareIdPattern, catalogIds, deprecatedCatalogIds, resolveChartOptions, chartOptionTarget } from './chunk-MPM7NRG7.js';
-import { catalogSchemaNames } from './chunk-E34DJ5LL.js';
-import { schemas, schemaEntries } from './chunk-7QBCWNWL.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/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 hasOwn(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) => hasOwn(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 (hasOwn(value, "items")) kinds.push("list");
-  if (hasOwn(value, "image")) kinds.push("image");
-  if (hasOwn(value, "video")) kinds.push("video");
-  if (hasOwn(value, "chart")) kinds.push("chart");
-  if (hasOwn(value, "table")) kinds.push("table");
-  if (hasOwn(value, "code")) kinds.push("code");
-  if (hasOwn(value, "metric")) kinds.push("metric");
-  if (hasOwn(value, "quote")) kinds.push("quote");
-  if (hasOwn(value, "timeline")) kinds.push("timeline");
-  return kinds;
-}
-function isImplicitBlocksComposition(value, inferred, options) {
-  if (options.slideRoot !== true || hasOwn(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 = hasOwn(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 (hasOwn(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 (hasOwn(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 (hasOwn(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 (hasOwn(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 (!hasOwn(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;
-}
-function dataIssues(value) {
-  const out = { errors: [], warnings: [] };
-  if (!isRecord(value) || !Array.isArray(value.slides)) return out;
-  const seen = /* @__PURE__ */ new Set();
-  const add = (diagnostics) => {
-    for (const diagnostic of diagnostics) {
-      const key = `${diagnostic.code}|${diagnostic.path}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      (diagnostic.severity === "error" ? out.errors : out.warnings).push(semanticIssue(diagnostic.path, diagnostic.message, { code: diagnostic.code }));
-    }
-  };
-  add(datasetDiagnostics(value));
-  const payload = (node, path) => {
-    if (isRecord(node.chart)) add(resolveChartData(node.chart, value, { path: pathFor(path, "chart") }).diagnostics);
-    if (isRecord(node.table)) add(resolveTableData(node.table, value, { path: pathFor(path, "table") }).diagnostics);
-  };
-  value.slides.forEach((slide, index) => {
-    if (!isRecord(slide)) return;
-    const slidePath = `/slides/${index}`;
-    payload(slide, slidePath);
-    visitContentPayloads(slide, slidePath, payload);
-  });
-  return out;
-}
-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) || hasOwn(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 (hasOwn(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 pointerValue(root, pointer2) {
-  let current = root;
-  for (const token of pointer2.split("/").slice(1)) {
-    const key = token.replaceAll("~1", "/").replaceAll("~0", "~");
-    if (Array.isArray(current)) current = current[Number(key)];
-    else if (isRecord(current) && hasOwn(current, key)) current = current[key];
-    else return void 0;
-  }
-  return current;
-}
-var datasetTableMessage = (field) => `'${field}' is not allowed on a dataset-backed table: it takes its headers, rows and column formats from the dataset`;
-function dataUnionErrors(errors, value) {
-  let kept = errors;
-  const schemaId = schemas.presentation.$id;
-  for (const union of errors) {
-    if (union.keyword !== "oneOf") continue;
-    const chartData = /\/chart\/data$/.test(union.instancePath) && /\/properties\/data\/oneOf$/.test(union.schemaPath);
-    const header = /\/table\/columns\/\d+$/.test(union.instancePath) && /\/properties\/columns\/items\/oneOf$/.test(union.schemaPath);
-    if (!chartData && !header) continue;
-    const target = pointerValue(value, union.instancePath);
-    if (!isRecord(target)) continue;
-    const branch = chartData ? hasOwn(target, "dataset") ? "DatasetRef" : hasOwn(target, "src") ? "ChartDataSource" : hasOwn(target, "rows") ? "ChartData" : void 0 : hasOwn(target, "value") ? "StyledTableCell" : hasOwn(target, "name") ? "DataColumn" : void 0;
-    const check = branch ? getAjv().getSchema(`${schemaId}#/$defs/${branch}`) : void 0;
-    if (!check || check(target) === true) continue;
-    const branchErrors = (check.errors ?? []).map((error) => ({ ...error, instancePath: `${union.instancePath}${error.instancePath}`, schemaPath: `#/$defs/${branch}${error.schemaPath.replace(/^#/, "")}` }));
-    const prefix = `${union.instancePath}/`;
-    kept = [...kept.filter((error) => error.instancePath !== union.instancePath && !error.instancePath.startsWith(prefix)), ...branchErrors];
-  }
-  const exclusions = kept.filter((error) => error.keyword === "false schema" && /\/table\/(rows|columns|fields)$/.test(error.instancePath) && /\/(then|else)\/properties\/(rows|columns|fields)\//.test(`${error.schemaPath}/`));
-  if (!exclusions.length) return kept;
-  const tables = new Set(exclusions.map((error) => error.instancePath.replace(/\/[^/]+$/, "")));
-  return kept.filter((error) => !(error.keyword === "if" && tables.has(error.instancePath))).map((error) => {
-    if (!exclusions.includes(error)) return error;
-    const field = error.instancePath.slice(error.instancePath.lastIndexOf("/") + 1);
-    return { ...error, message: field === "fields" ? "'fields' applies only to a dataset-backed table; add 'dataset' or remove 'fields'" : datasetTableMessage(field) };
-  });
-}
-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 ajvErrors = valid ? [] : typedVariableErrors(resolved.validate.errors ?? [], subject);
-  const errors = (resolved.schemaName === "presentation" ? dataUnionErrors(ajvErrors, subject) : ajvErrors).map(toIssue);
-  const warnings = [];
-  if (resolved.schemaName === "presentation") {
-    errors.push(...validatePresentationSemantics(subject));
-    errors.push(...variableIssues.errors);
-    const data = dataIssues(subject);
-    errors.push(...data.errors);
-    warnings.push(...presentationReferenceWarnings(subject));
-    warnings.push(...data.warnings);
-    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 { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, unusedReferenceWarnings, validate, validateCatalogRecord, validatePresentation, validationDefinition };