@openpresentation/opf 0.11.4 → 0.12.1

package/dist/chunk-FDCWQHWO.js

@@ -1,1366 +0,0 @@
-import { MAX_COMPOSITION_DEPTH, tableGrid } from './chunk-3H2U7FDR.js';
-import { schemas, schemaEntries } from './chunk-KJKASEPE.js';
-import { catalogSchemaNames } from './chunk-AEUSVEUY.js';
-import Ajv2020 from 'ajv/dist/2020.js';
-import addFormats from 'ajv-formats';
-
-// src/content-walk.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function pathFor(parentPath, key) {
-  return parentPath === "/" ? `/${key}` : `${parentPath}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
-}
-var bareIdPattern = /^[a-z0-9][a-z0-9-]*$/;
-var promotedRegionKeys = [
-  "left",
-  "center",
-  "right",
-  "left+center",
-  "center+right",
-  "left+center+right",
-  "top",
-  "middle",
-  "bottom",
-  "top+middle",
-  "middle+bottom",
-  "top+middle+bottom",
-  "top:left",
-  "top:center",
-  "top:right",
-  "top:left+center",
-  "top:center+right",
-  "top:left+center+right",
-  "middle:left",
-  "middle:center",
-  "middle:right",
-  "middle:left+center",
-  "middle:center+right",
-  "middle:left+center+right",
-  "bottom:left",
-  "bottom:center",
-  "bottom:right",
-  "bottom:left+center",
-  "bottom:center+right",
-  "bottom:left+center+right",
-  "top+middle:left",
-  "top+middle:center",
-  "top+middle:right",
-  "top+middle:left+center",
-  "top+middle:center+right",
-  "top+middle:left+center+right",
-  "middle+bottom:left",
-  "middle+bottom:center",
-  "middle+bottom:right",
-  "middle+bottom:left+center",
-  "middle+bottom:center+right",
-  "middle+bottom:left+center+right",
-  "top+middle+bottom:left",
-  "top+middle+bottom:center",
-  "top+middle+bottom:right",
-  "top+middle+bottom:left+center",
-  "top+middle+bottom:center+right",
-  "top+middle+bottom:left+center+right"
-];
-function visitContentPayloads(slide, slidePath, visit) {
-  const walk = (payload, path, depth, ancestors) => {
-    visit(payload, path);
-    if (!Array.isArray(payload.blocks) || depth >= MAX_COMPOSITION_DEPTH || ancestors.includes(payload)) return;
-    const nested = [...ancestors, payload];
-    const blocksPath = pathFor(path, "blocks");
-    payload.blocks.forEach((block, index) => {
-      if (isRecord(block)) walk(block, `${blocksPath}/${index}`, depth + 1, nested);
-    });
-  };
-  if (Array.isArray(slide.blocks)) {
-    const blocksPath = pathFor(slidePath, "blocks");
-    slide.blocks.forEach((block, index) => {
-      if (isRecord(block)) walk(block, `${blocksPath}/${index}`, 0, []);
-    });
-  }
-  for (const key of promotedRegionKeys) {
-    const region = slide[key];
-    if (isRecord(region)) walk(region, pathFor(slidePath, key), 0, []);
-  }
-}
-
-// src/generated/catalog-ids.ts
-var catalogIds = {
-  audiences: [
-    "executives",
-    "board",
-    "engineering-team",
-    "investors",
-    "customers",
-    "sales-team",
-    "marketing-team",
-    "all-hands",
-    "candidates",
-    "regulators",
-    "executive",
-    "investor",
-    "technical",
-    "sales",
-    "marketing",
-    "academic",
-    "internal-team",
-    "customer",
-    "general-public",
-    "media",
-    "partner",
-    "regulatory"
-  ],
-  purposes: [
-    "inform",
-    "decide",
-    "align",
-    "persuade",
-    "educate",
-    "report",
-    "pitch",
-    "sell",
-    "plan"
-  ],
-  tones: [
-    "formal",
-    "casual",
-    "inspirational",
-    "technical",
-    "persuasive",
-    "authoritative",
-    "conversational"
-  ],
-  themes: [
-    "minimal",
-    "classic",
-    "dark",
-    "bold"
-  ],
-  layouts: [
-    "blank",
-    "chart-1x",
-    "chart-2x",
-    "chart-3x",
-    "code-1x",
-    "image-1x",
-    "image-2x",
-    "image-3x",
-    "image-bleed",
-    "list-1x",
-    "list-2x",
-    "list-3x",
-    "list-4x",
-    "list-5x",
-    "list-6x",
-    "media-1x",
-    "number-1x",
-    "number-2x",
-    "number-3x",
-    "number-4x",
-    "number-5x",
-    "number-6x",
-    "quote-1x",
-    "table-1x",
-    "text-1x",
-    "text-2x",
-    "text-3x",
-    "timeline-1x",
-    "title",
-    "title-subtitle",
-    "title-slide",
-    "two-column",
-    "image-focus",
-    "data-visualization",
-    "quote-highlight",
-    "section-divider",
-    "agenda",
-    "thank-you-cta",
-    "bullet-list",
-    "three-column",
-    "icon-grid",
-    "faq",
-    "stats-metrics",
-    "comparison",
-    "swot-analysis",
-    "matrix-quadrant",
-    "funnel-pyramid",
-    "timeline",
-    "process-flow",
-    "photo-grid",
-    "before-after",
-    "testimonial-grid",
-    "team-bio",
-    "pricing-table",
-    "roadmap",
-    "product-feature",
-    "executive-summary",
-    "key-takeaway",
-    "chapter-recap",
-    "qa-discussion",
-    "single-message-statement",
-    "one-column-explainer",
-    "case-study",
-    "pros-cons",
-    "feature-comparison-matrix",
-    "venn-overlap",
-    "decision-tree",
-    "kpi-scorecard",
-    "dashboard",
-    "waterfall-bridge",
-    "benchmark-target-table",
-    "heatmap-cohort",
-    "risk-heatmap",
-    "forecast-scenario",
-    "swimlane-process",
-    "gantt-project-plan",
-    "circular-lifecycle",
-    "customer-journey",
-    "org-chart",
-    "capability-map",
-    "logic-tree",
-    "hub-and-spoke",
-    "architecture-stack",
-    "ecosystem-map",
-    "network-dependency-map",
-    "wheel-radial",
-    "geographic-map",
-    "screenshot-walkthrough",
-    "market-size",
-    "persona-grid",
-    "competitive-landscape",
-    "business-model-canvas",
-    "customer-logos",
-    "executive-decision",
-    "status-rag",
-    "raci-matrix",
-    "action-plan",
-    "assumptions-dependencies",
-    "appendix-index",
-    "detailed-data-table"
-  ],
-  chartTypes: [
-    "100pct-stacked-area-3x",
-    "100pct-stacked-bar-3x",
-    "100pct-stacked-column-3x",
-    "area",
-    "bar",
-    "box-and-whisker",
-    "column",
-    "doughnut",
-    "filled-radar",
-    "funnel",
-    "histogram",
-    "line",
-    "line-with-markers",
-    "pareto",
-    "pie",
-    "radar",
-    "radar-with-markers",
-    "scatter",
-    "stacked-area-3x",
-    "stacked-bar-3x",
-    "stacked-column-3x",
-    "stacked-line-3x",
-    "stacked-line-with-markers-3x",
-    "treemap",
-    "waterfall",
-    "world",
-    "100pct-bullet-bar",
-    "100pct-bullet-bar-2x",
-    "100pct-bullet-bar-3x",
-    "100pct-bullet-column",
-    "100pct-bullet-column-2x",
-    "100pct-bullet-column-3x",
-    "100pct-progress-bar",
-    "100pct-stacked-area-2x",
-    "100pct-stacked-bar-2x",
-    "100pct-stacked-column-2x",
-    "australia",
-    "box-and-whisker-2x",
-    "box-and-whisker-3x",
-    "bullet-bar",
-    "bullet-bar-2x",
-    "bullet-bar-3x",
-    "bullet-column",
-    "bullet-column-2x",
-    "bullet-column-3x",
-    "canada",
-    "clustered-bar-2x",
-    "clustered-column",
-    "dot-plot",
-    "dot-plot-2x",
-    "dot-plot-3x",
-    "dot-plot-4x",
-    "dot-plot-5x",
-    "dot-plot-6x",
-    "dumbbell",
-    "line-2x",
-    "line-3x",
-    "line-with-high-low",
-    "line-with-high-low-and-markers",
-    "line-with-markers-2x",
-    "line-with-markers-3x",
-    "sparkline",
-    "sparkline-2x",
-    "sparkline-3x",
-    "sparkline-4x",
-    "sparkline-5x",
-    "sparkline-6x",
-    "stacked-area-2x",
-    "stacked-bar-2x",
-    "stacked-column-2x",
-    "stacked-line-2x",
-    "stacked-line-with-markers-2x",
-    "treemap-2x",
-    "treemap-3x",
-    "united-kingdom",
-    "united-states"
-  ],
-  narratives: [
-    "problem-solution",
-    "scqa",
-    "pyramid-principle",
-    "situation-complication-resolution",
-    "what-so-what-now-what",
-    "strategic-narrative",
-    "golden-circle",
-    "conference-talk",
-    "transformation-arc",
-    "pitch-deck",
-    "early-startup-pitch",
-    "venture-pitch",
-    "persuasive-sales",
-    "sparkline",
-    "company-intro",
-    "marketing-strategy",
-    "product-launch",
-    "strategic-advisory",
-    "challenge-resolution",
-    "project-proposal",
-    "vision-roadmap",
-    "failure-analysis",
-    "star-method",
-    "classic-story",
-    "heros-journey",
-    "business-narrative",
-    "change-story",
-    "rags-to-riches",
-    "underdog-victory",
-    "survival-story",
-    "educate",
-    "persuade",
-    "reveal",
-    "justice",
-    "innovation",
-    "focus",
-    "qbr",
-    "business-review",
-    "board-meeting",
-    "weekly-progress",
-    "status-update",
-    "performance-review",
-    "survey-analysis",
-    "trend-analysis",
-    "data-story",
-    "employee-review",
-    "performance-improvement-plan",
-    "capacity-planning"
-  ],
-  socialPlatforms: [
-    "linkedin",
-    "x",
-    "github",
-    "youtube",
-    "instagram",
-    "facebook",
-    "tiktok",
-    "threads",
-    "mastodon",
-    "bluesky"
-  ],
-  languages: [
-    "afrikaans",
-    "albanian",
-    "amharic",
-    "arabic",
-    "armenian",
-    "aymara",
-    "azerbaijani",
-    "bengali",
-    "berber-latin",
-    "bosnian-latin",
-    "bulgarian",
-    "catalan",
-    "cebuano",
-    "chinese-simplified",
-    "chinese-traditional",
-    "chittagonian",
-    "croatian",
-    "czech",
-    "danish",
-    "dutch",
-    "english",
-    "english-au",
-    "english-ca",
-    "english-gb",
-    "english-in",
-    "english-us",
-    "estonian",
-    "filipino",
-    "finnish",
-    "french",
-    "fulfulde",
-    "galician",
-    "georgian",
-    "german",
-    "greek",
-    "gujarati",
-    "hausa",
-    "hebrew",
-    "hindi",
-    "hungarian",
-    "igbo",
-    "indonesian",
-    "italian",
-    "japanese",
-    "kannada",
-    "kazakh",
-    "khmer",
-    "kinyarwanda",
-    "korean",
-    "kurmanji",
-    "latvian",
-    "lithuanian",
-    "macedonian",
-    "malagasy",
-    "malay",
-    "malayalam",
-    "maori",
-    "marathi",
-    "mongolian",
-    "nepali",
-    "norwegian",
-    "odia",
-    "oromo",
-    "pashto",
-    "persian",
-    "polish",
-    "portuguese",
-    "punjabi-gurmukhi",
-    "punjabi-shahmukhi",
-    "romanian",
-    "russian",
-    "serbian-cyrillic",
-    "serbian-latin",
-    "shona",
-    "slovak",
-    "slovenian",
-    "somali",
-    "spanish",
-    "swahili",
-    "swedish",
-    "tagalog",
-    "tajik",
-    "tamil",
-    "telugu",
-    "thai",
-    "turkish",
-    "ukrainian",
-    "urdu",
-    "uzbek-latin",
-    "vietnamese-quoc-ngu",
-    "xhosa",
-    "yoruba",
-    "zulu"
-  ],
-  colorSchemes: [
-    "black-and-white",
-    "bold-red",
-    "boost",
-    "burnt-orange",
-    "cool-horizon",
-    "corporate-blue",
-    "deep-purple",
-    "forest-green",
-    "golden-yellow",
-    "luxury",
-    "pastel-red",
-    "slate-gray",
-    "steel-blue",
-    "vibes"
-  ],
-  fontSchemes: [
-    "consolas",
-    "courier-new",
-    "arial",
-    "calibri",
-    "impact",
-    "lucida-sans",
-    "segoe-ui",
-    "segoe-ui-light",
-    "tahoma",
-    "trebuchet-ms",
-    "verdana",
-    "bookman",
-    "century-schoolbook",
-    "constantia",
-    "garamond",
-    "rockwell",
-    "times-new-roman",
-    "aptos",
-    "grandview",
-    "seaford",
-    "skeena",
-    "tenorite",
-    "georgia",
-    "microsoft-yahei",
-    "simsun",
-    "fangsong",
-    "yu-gothic",
-    "pmingliu",
-    "mingliu",
-    "ms-mincho",
-    "malgun-gothic",
-    "batang",
-    "gungsuh",
-    "mangal",
-    "nirmala-ui",
-    "latha",
-    "david",
-    "miriam",
-    "gisha",
-    "vrinda",
-    "shruti",
-    "tunga",
-    "kartika",
-    "kalinga",
-    "raavi",
-    "gautami",
-    "arabic-typesetting",
-    "microsoft-jhenghei",
-    "meiryo",
-    "angsana-new",
-    "aparajita",
-    "dilleniaupc",
-    "sakkal-majalla",
-    "shonar-bangla",
-    "sylfaen",
-    "traditional-arabic",
-    "montserrat",
-    "open-sans",
-    "poppins",
-    "pt-serif",
-    "raleway",
-    "roboto",
-    "noto-sans-arabic",
-    "noto-sans-armenian",
-    "noto-sans-bengali",
-    "noto-sans-devangari",
-    "noto-sans-georgian",
-    "noto-sans-gujarati",
-    "noto-sans-gurmukhi",
-    "noto-sans-hebrew",
-    "noto-sans-jp",
-    "noto-sans-kannada",
-    "noto-sans-kr",
-    "noto-sans-malayalam",
-    "noto-sans-mongolian",
-    "noto-sans-oriya",
-    "noto-sans-sc",
-    "noto-sans-tamil",
-    "noto-sans-tc",
-    "noto-sans-telugu",
-    "noto-sans",
-    "noto-sans-thai",
-    "noto-nastaliq-urdu",
-    "noto-naksh-arabic",
-    "noto-sans-ethiopic",
-    "noto-sans-khmer",
-    "nyala",
-    "daunpenh",
-    "khmer-ui"
-  ]
-};
-var deprecatedCatalogIds = {
-  "chartTypes/100pct-bullet-bar": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-bullet-bar-2x": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-bullet-bar-3x": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-bullet-column": "100pct-stacked-column-3x",
-  "chartTypes/100pct-bullet-column-2x": "100pct-stacked-column-3x",
-  "chartTypes/100pct-bullet-column-3x": "100pct-stacked-column-3x",
-  "chartTypes/100pct-progress-bar": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-stacked-area-2x": "100pct-stacked-area-3x",
-  "chartTypes/100pct-stacked-bar-2x": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-stacked-column-2x": "100pct-stacked-column-3x",
-  "chartTypes/australia": "world",
-  "chartTypes/box-and-whisker-2x": "box-and-whisker",
-  "chartTypes/box-and-whisker-3x": "box-and-whisker",
-  "chartTypes/bullet-bar": "bar",
-  "chartTypes/bullet-bar-2x": "bar",
-  "chartTypes/bullet-bar-3x": "bar",
-  "chartTypes/bullet-column": "column",
-  "chartTypes/bullet-column-2x": "column",
-  "chartTypes/bullet-column-3x": "column",
-  "chartTypes/canada": "world",
-  "chartTypes/clustered-bar-2x": "bar",
-  "chartTypes/clustered-column": "column",
-  "chartTypes/dot-plot": "scatter",
-  "chartTypes/dot-plot-2x": "scatter",
-  "chartTypes/dot-plot-3x": "scatter",
-  "chartTypes/dot-plot-4x": "scatter",
-  "chartTypes/dot-plot-5x": "scatter",
-  "chartTypes/dot-plot-6x": "scatter",
-  "chartTypes/dumbbell": "scatter",
-  "chartTypes/line-2x": "line",
-  "chartTypes/line-3x": "line",
-  "chartTypes/line-with-high-low": "line",
-  "chartTypes/line-with-high-low-and-markers": "line-with-markers",
-  "chartTypes/line-with-markers-2x": "line-with-markers",
-  "chartTypes/line-with-markers-3x": "line-with-markers",
-  "chartTypes/sparkline": "line",
-  "chartTypes/sparkline-2x": "line",
-  "chartTypes/sparkline-3x": "line",
-  "chartTypes/sparkline-4x": "line",
-  "chartTypes/sparkline-5x": "line",
-  "chartTypes/sparkline-6x": "line",
-  "chartTypes/stacked-area-2x": "stacked-area-3x",
-  "chartTypes/stacked-bar-2x": "stacked-bar-3x",
-  "chartTypes/stacked-column-2x": "stacked-column-3x",
-  "chartTypes/stacked-line-2x": "stacked-line-3x",
-  "chartTypes/stacked-line-with-markers-2x": "stacked-line-with-markers-3x",
-  "chartTypes/treemap-2x": "treemap",
-  "chartTypes/treemap-3x": "treemap",
-  "chartTypes/united-kingdom": "world",
-  "chartTypes/united-states": "world"
-};
-
-// src/validation-definitions.ts
-var schemaLocations;
-var issueLocations = /* @__PURE__ */ new WeakMap();
-function rememberValidationDefinition(issue, 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(issue, {
-    ...parent,
-    pointer: parent.pointer + suffix,
-    uri: parent.uri + suffix
-  });
-}
-function validationDefinition(issue) {
-  return issueLocations.get(issue);
-}
-
-// 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 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 issue = {
-    path: error.instancePath || "/",
-    message: error.message ?? "failed validation",
-    keyword: error.keyword,
-    schemaPath: error.schemaPath,
-    params: error.params
-  };
-  rememberValidationDefinition(issue, error.parentSchema, error.keyword);
-  return issue;
-}
-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");
-  if (hasBlocks || explicitType === "group") {
-    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)) {
-      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];
-  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 issue of tableGrid(payload.table).issues) issues.push(semanticIssue(pathFor(path, "table") + issue.path.slice(5).replaceAll(".", "/"), issue.message));
-      };
-      payloadTableIssues(slide, slidePath);
-      visitContentPayloads(slide, slidePath, payloadTableIssues);
-    }
-  });
-  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, issue) {
-  if (issue) {
-    issues.push(issue);
-  }
-}
-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));
-  }
-  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) || 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));
-    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 [];
-}
-function validate(value, schemaOrKind = "presentation") {
-  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 valid = resolved.validate(value) === true;
-  const errors = valid ? [] : (resolved.validate.errors ?? []).map(toIssue);
-  const warnings = [];
-  if (resolved.schemaName === "presentation") {
-    errors.push(...validatePresentationSemantics(value));
-    warnings.push(...presentationReferenceWarnings(value));
-  } 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
-  };
-}
-function assertValid(value, schemaOrKind = "presentation") {
-  const result = validate(value, schemaOrKind);
-  if (!result.valid) {
-    throw new OPFValidationError(result);
-  }
-  return value;
-}
-function validatePresentation(value) {
-  return validate(value, "presentation");
-}
-function assertValidPresentation(value) {
-  assertValid(value, "presentation");
-}
-function validateCatalogRecord(kind, value) {
-  return validate(value, kind);
-}
-function assertValidCatalogRecord(kind, value) {
-  assertValid(value, kind);
-}
-
-export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, bareIdPattern, isRecord, promotedRegionKeys, validate, validateCatalogRecord, validatePresentation, validationDefinition, visitContentPayloads };