@openpresentation/opf 0.20.4 → 0.21.0

package/dist/{chunk-2M7U4WL3.js → chunk-XQARTOZJ.js}

@@ -1,5 +1,5 @@
-import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, imageBackground, tableGrid, timelineTextColor, LOGO_SHAPES, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, resolveReference, textWidthMeasurer, normalizeHexColor, resolveColorRef, resolveDesignRecords, resolveFontFamilies, checkCatalogsOption, provenanceOf, unresolvedReference, OPFUnresolvedReferenceError, resolveColorRoles, resolveCanvasDimensions, resolveSlideVariables, defaultSlideBackground, isRecord, hasContentVariables, isTemplate, instantiateForValidation, layoutTemplateIssues, resolveScriptFonts, catalogReferenceSites, parseReference, catalogGroupDeclared, pointerPath, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, catalogRecords, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, catalogKinds, catalogGroupSource, registeredCatalog, OPFCompositionError, composeSlide } from './chunk-XAYMPBNE.js';
-import { schemaEntries, schemas } from './chunk-VFMHM2IL.js';
+import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, chartSeriesPalette, normalizeHexColor, resolveChartColors, colorContrast, imageBackground, tableGrid, timelineTextColor, LOGO_SHAPES, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, resolveReference, textWidthMeasurer, resolveColorRef, resolveDesignRecords, resolveFontFamilies, checkCatalogsOption, provenanceOf, unresolvedReference, OPFUnresolvedReferenceError, resolveColorRoles, resolveCanvasDimensions, resolveSlideVariables, defaultSlideBackground, isRecord, hasContentVariables, isTemplate, instantiateForValidation, layoutTemplateIssues, resolveScriptFonts, catalogReferenceSites, parseReference, catalogGroupDeclared, pointerPath, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, catalogRecords, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, catalogKinds, catalogGroupSource, registeredCatalog, OPFCompositionError, composeSlide } from './chunk-X6SB52RP.js';
+import { schemas, schemaEntries } from './chunk-BWWGYOOG.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
@@ -87,6 +87,125 @@ function unusedReferenceWarnings(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/union-errors.ts
+var compiled = /* @__PURE__ */ new WeakMap();
+var origin = /* @__PURE__ */ new WeakMap();
+var isUnion = (error) => (error.keyword === "oneOf" || error.keyword === "anyOf") && Array.isArray(error.schema);
+var key = (error) => `${error.instancePath}\0${error.keyword}\0${error.message}\0${JSON.stringify(error.params)}`;
+var depth = (pointer4) => pointer4 ? pointer4.split("/").length - 1 : 0;
+var original = (node) => {
+  let current = node;
+  while (current && typeof current === "object" && origin.has(current)) current = origin.get(current);
+  return current;
+};
+function qualify(node, rootId) {
+  if (Array.isArray(node)) {
+    const copy = node.map((item) => qualify(item, rootId));
+    origin.set(copy, node);
+    return copy;
+  }
+  if (node && typeof node === "object") {
+    const copy = {};
+    for (const [name, value] of Object.entries(node)) copy[name] = name === "$ref" && typeof value === "string" && value.startsWith("#") ? rootId + value : qualify(value, rootId);
+    origin.set(copy, node);
+    return copy;
+  }
+  return node;
+}
+function branchValidator(ajv2, rootId, branch) {
+  let validate2 = compiled.get(branch);
+  if (!validate2) {
+    validate2 = ajv2.compile(qualify(branch, rootId));
+    compiled.set(branch, validate2);
+  }
+  return validate2;
+}
+function branchLabel(branch, index) {
+  if (typeof branch.$ref === "string") return branch.$ref.slice(branch.$ref.lastIndexOf("/") + 1);
+  if (typeof branch.type === "string") return branch.type;
+  if (Array.isArray(branch.type)) return branch.type.join("|");
+  if ("const" in branch) return JSON.stringify(branch.const);
+  return `option ${index + 1}`;
+}
+function describe(errors, base) {
+  const types = [...new Set(errors.filter((error) => depth(error.instancePath) === base && error.keyword === "type").flatMap((error) => [error.params.type].flat()))];
+  if (types.length) return `must be ${types.join(" or ")}`;
+  const shallow = [...errors].filter((error) => !isUnion(error) || errors.every(isUnion)).sort((a, b) => depth(a.instancePath) - depth(b.instancePath))[0];
+  if (!shallow) return "does not match";
+  const rest = shallow.instancePath.split("/").slice(base + 1).join("/");
+  return depth(shallow.instancePath) === base || !rest ? shallow.message ?? "does not match" : `${shallow.message} at /${rest}`;
+}
+function bestMatchErrors(ajv2, rootId, errors) {
+  const unions = errors.filter(isUnion);
+  if (!unions.length) return errors;
+  const analyses = [];
+  for (const union of unions) {
+    const analysis = analyze(ajv2, rootId, union);
+    if (analysis) analyses.push(analysis);
+  }
+  if (!analyses.length) return errors;
+  const within = (inner, other) => other !== inner && [...inner.span].every((entry) => other.span.has(entry)) && (other.span.size > inner.span.size || errors.indexOf(other.union) > errors.indexOf(inner.union));
+  const outer = analyses.filter((analysis) => !analyses.some((other) => within(analysis, other)));
+  const replaced = new Map(outer.map((analysis) => [analysis.union, analysis]));
+  const drop = new Set(outer.flatMap((analysis) => [...analysis.span]));
+  const result = [];
+  for (const error of errors) {
+    const analysis = replaced.get(error);
+    if (analysis) result.push(...analysis.replacement);
+    else if (!drop.has(key(error))) result.push(error);
+  }
+  return result;
+}
+function analyze(ajv2, rootId, union) {
+  const branches = union.schema;
+  const base = depth(union.instancePath);
+  const results = [];
+  for (const [index, branch] of branches.entries()) {
+    if (!branch || typeof branch !== "object") return void 0;
+    const validate2 = branchValidator(ajv2, rootId, branch);
+    if (validate2(union.data) === true) return void 0;
+    const raw = (validate2.errors ?? []).map((error) => ({ ...error, instancePath: union.instancePath + error.instancePath }));
+    results.push({ label: branchLabel(branch, index), errors: raw });
+  }
+  const span = /* @__PURE__ */ new Set([key(union), ...results.flatMap((result) => result.errors.map(key))]);
+  const reduced = results.map((result) => ({ label: result.label, errors: bestMatchErrors(ajv2, rootId, result.errors) }));
+  const mismatch = (error) => {
+    const level = depth(error.instancePath) - base;
+    return level === 0 && (error.keyword === "type" || isUnion(error)) || level === 1 && error.keyword === "const";
+  };
+  const matched = reduced.filter((result) => result.errors.length && !result.errors.some(mismatch));
+  const reach = (errors) => Math.min(...errors.map((error) => depth(error.instancePath)));
+  const ranked = [...matched].sort((a, b) => reach(b.errors) - reach(a.errors));
+  const summary = (list) => list.map((result) => `${result.label}: ${describe(result.errors, base)}`);
+  const named = (list) => list.length > 1 ? `${list.slice(0, -1).join(", ")} or ${list.at(-1)}` : list[0] ?? "";
+  const lead = ranked[0];
+  if (!lead) {
+    const rootTypes = reduced.map((result) => result.errors.filter((error) => depth(error.instancePath) === base && error.keyword === "type"));
+    const plain = rootTypes.every((list, index) => list.length === reduced[index]?.errors.length && list.length > 0);
+    const types = [...new Set(rootTypes.flatMap((list) => list.flatMap((error) => [error.params.type].flat())))].map(String);
+    return { union, span, replacement: [{ ...union, message: plain ? `must be ${named(types)}` : union.message, alternatives: summary(reduced) }] };
+  }
+  const top = ranked.filter((result) => reach(result.errors) === reach(lead.errors));
+  const others = reduced.filter((result) => !top.includes(result));
+  const single = (result) => {
+    const only = result.errors[0];
+    return result.errors.length === 1 && only && depth(only.instancePath) === base ? only : void 0;
+  };
+  const singles = top.map(single);
+  const keyword = singles[0]?.keyword;
+  if (top.length > 1 && (keyword === "format" || keyword === "required") && singles.every((error) => error?.keyword === keyword)) {
+    const values = singles.map((error) => JSON.stringify(keyword === "format" ? error?.params.format : error?.params.missingProperty).replace(/^"|"$/g, keyword === "format" ? '"' : "'"));
+    const message = keyword === "format" ? `must match format ${named(values)}` : `must have required property ${named(values)}`;
+    return { union, span, replacement: [{ ...singles[0], message, alternatives: summary(top) }] };
+  }
+  const chosen = top.flatMap((result) => result.errors).map((error, index) => {
+    const mapped = { ...error, parentSchema: original(error.parentSchema), schema: original(error.schema) };
+    if (index === 0 && others.length) mapped.alternatives = summary(others);
+    return mapped;
+  });
+  return { union, span, replacement: chosen };
+}
+
 // src/validation-definitions.ts
 var schemaLocations;
 var issueLocations = /* @__PURE__ */ new WeakMap();
@@ -107,8 +226,8 @@ function rememberValidationDefinition(issue2, parentSchema, keyword) {
           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");
+        for (const [key2, value] of Object.entries(current.value)) {
+          const segment = key2.replaceAll("~", "~0").replaceAll("/", "~1");
           stack.push({ value, pointer: `${current.pointer}/${segment}` });
         }
       }
@@ -254,7 +373,8 @@ function toIssue(error) {
     message: slideDimensions ? "a slide's design cannot set 'dimensions': a PPTX has one slide size, so set design.dimensions on the deck (or its theme)" : error.message ?? "failed validation",
     keyword: error.keyword,
     schemaPath: error.schemaPath,
-    params: error.params
+    params: error.params,
+    ...error.alternatives?.length ? { alternatives: error.alternatives } : {}
   };
   rememberValidationDefinition(issue2, error.parentSchema, error.keyword);
   return issue2;
@@ -268,8 +388,8 @@ function semanticIssue(path, message, params = {}) {
     params
   };
 }
-function hasOwn(value, key) {
-  return Object.hasOwn(value, key);
+function hasOwn(value, key2) {
+  return Object.hasOwn(value, key2);
 }
 function isEnUkTag(value) {
   return typeof value === "string" && value.toLowerCase() === "en-uk";
@@ -391,20 +511,20 @@ function validateContentPayload(value, path, options = {}) {
   }
   return issues;
 }
-function slideRegion(key) {
-  if (key.includes(":")) {
-    const [rowPart, columnPart] = key.split(":");
+function slideRegion(key2) {
+  if (key2.includes(":")) {
+    const [rowPart, columnPart] = key2.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];
+  if (key2 in columnSpans) {
+    const columns = columnSpans[key2];
     return columns ? { rows: [0, 1, 2], columns } : void 0;
   }
-  if (key in rowSpans) {
-    const rows = rowSpans[key];
+  if (key2 in rowSpans) {
+    const rows = rowSpans[key2];
     return rows ? { rows, columns: [0, 1, 2] } : void 0;
   }
   return void 0;
@@ -417,7 +537,7 @@ function regionsOverlap(left, right) {
 }
 function validateSlideRegions(slide, slidePath) {
   const issues = [];
-  const regionKeys = Object.keys(slide).filter((key) => promotedRegionKeySet.has(key));
+  const regionKeys = Object.keys(slide).filter((key2) => promotedRegionKeySet.has(key2));
   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", {
@@ -428,10 +548,10 @@ function validateSlideRegions(slide, slidePath) {
   if (regionKeys.length === 0 && rootFields.length > 0) {
     issues.push(...validateContentPayload(slide, slidePath, { slideRoot: true }));
   }
-  for (const key of regionKeys) {
-    const value = slide[key];
+  for (const key2 of regionKeys) {
+    const value = slide[key2];
     if (isRecord(value)) {
-      issues.push(...validateContentPayload(value, pathFor(slidePath, key)));
+      issues.push(...validateContentPayload(value, pathFor(slidePath, key2)));
     }
   }
   for (let leftIndex = 0; leftIndex < regionKeys.length; leftIndex += 1) {
@@ -455,19 +575,19 @@ function validateSlideRegions(slide, slidePath) {
 }
 function deckMetadataIssues(value) {
   const issues = [];
-  const entries = (key) => {
-    const field = value[key];
-    if (Array.isArray(field)) return field.flatMap((entry, index) => isRecord(entry) ? [{ entry, path: `/${key}/${index}` }] : []);
-    return isRecord(field) ? [{ entry: field, path: `/${key}` }] : [];
+  const entries = (key2) => {
+    const field = value[key2];
+    if (Array.isArray(field)) return field.flatMap((entry, index) => isRecord(entry) ? [{ entry, path: `/${key2}/${index}` }] : []);
+    return isRecord(field) ? [{ entry: field, path: `/${key2}` }] : [];
   };
   const organizationIds = /* @__PURE__ */ new Set();
-  for (const key of ["organization", "speaker"]) {
+  for (const key2 of ["organization", "speaker"]) {
     const seen = /* @__PURE__ */ new Set();
-    for (const { entry, path } of entries(key)) {
+    for (const { entry, path } of entries(key2)) {
       if (typeof entry.id !== "string") continue;
-      if (seen.has(entry.id)) issues.push(semanticIssue(`${path}/id`, `${key} ids must be unique within a presentation`, { id: entry.id }));
+      if (seen.has(entry.id)) issues.push(semanticIssue(`${path}/id`, `${key2} ids must be unique within a presentation`, { id: entry.id }));
       seen.add(entry.id);
-      if (key === "organization") organizationIds.add(entry.id);
+      if (key2 === "organization") organizationIds.add(entry.id);
     }
   }
   for (const { entry, path } of entries("speaker")) {
@@ -621,9 +741,9 @@ function dataIssues(value) {
   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);
+      const key2 = `${diagnostic.code}|${diagnostic.path}`;
+      if (seen.has(key2)) continue;
+      seen.add(key2);
       (diagnostic.severity === "error" ? out.errors : out.warnings).push(semanticIssue(diagnostic.path, diagnostic.message, { code: diagnostic.code }));
     }
   };
@@ -808,9 +928,9 @@ function presentationReferenceWarnings(value, catalogs) {
     };
     highlightWarnings(slide, slidePath);
     visitContentPayloads(slide, slidePath, highlightWarnings);
-    for (const key of Object.keys(slide)) {
-      if (promotedRegionKeySet.has(key)) {
-        issues.push(...chartTypeWarnings(slide[key], pathFor(slidePath, key)));
+    for (const key2 of Object.keys(slide)) {
+      if (promotedRegionKeySet.has(key2)) {
+        issues.push(...chartTypeWarnings(slide[key2], pathFor(slidePath, key2)));
       }
     }
   });
@@ -835,7 +955,7 @@ function contentDepthIssues(value) {
     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: [] });
+    for (const key2 of promotedRegionKeys) if (hasOwn(slide, key2)) stack.push({ value: slide[key2], path: `/slides/${index}/${key2}`, depth: 0, ancestors: [] });
   });
   while (stack.length) {
     const entry = stack.pop();
@@ -890,9 +1010,9 @@ function typedVariableErrors(errors, value) {
 function pointerValue(root, pointer4) {
   let current = root;
   for (const token of pointer4.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];
+    const key2 = token.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (Array.isArray(current)) current = current[Number(key2)];
+    else if (isRecord(current) && hasOwn(current, key2)) current = current[key2];
     else return void 0;
   }
   return current;
@@ -955,7 +1075,8 @@ function validateAgainstSchema(value, schemaOrKind = "presentation", options = {
   }
   const valid = resolved.validate(subject) === true;
   const ajvErrors = valid ? [] : typedVariableErrors(resolved.validate.errors ?? [], subject);
-  const mapped = (resolved.schemaName === "presentation" ? dataUnionErrors(ajvErrors, subject) : ajvErrors).map(toIssue);
+  const specific = resolved.schemaName === "presentation" ? dataUnionErrors(ajvErrors, subject) : ajvErrors;
+  const mapped = bestMatchErrors(getAjv(), schemas[resolved.schemaName].$id, specific).map(toIssue);
   const errors = mapped;
   if (resolved.schemaName === "layout" && valid) for (const issue2 of layoutTemplateIssues(subject)) errors.push(semanticIssue(issue2.path, issue2.message, { code: issue2.code }));
   const warnings = [];
@@ -1283,20 +1404,6 @@ function readableColor(candidates, sample, minimum) {
     if (worstContrast(candidate, sample).ratio >= minimum) return candidate;
   return void 0;
 }
-var DEFAULT_CHART_PALETTE = [
-  "#2874A6",
-  "#1B4F72",
-  "#5499C7",
-  "#7BDBB2",
-  "#3AC67A",
-  "#24A89E",
-  "#F59E0B",
-  "#EF4444",
-  "#8B5CF6",
-  "#14B8A6",
-  "#0F172A",
-  "#64748B"
-];
 
 // src/rule-content.ts
 var pointer2 = (...parts2) => parts2.length ? "/" + parts2.map((part) => String(part).replaceAll("~", "~0").replaceAll("/", "~1")).join("/") : "";
@@ -1356,9 +1463,9 @@ function textValues(slide, slidePath) {
     const metric = node.metric;
     if (typeof metric === "string") push(at2("metric"), metric, "metric", "metric");
     else if (metric && typeof metric === "object")
-      for (const key of ["value", "label", "unit", "delta"]) {
-        const value = metric[key];
-        if (typeof value === "string") push(at2("metric", key), value, "metric", "metric");
+      for (const key2 of ["value", "label", "unit", "delta"]) {
+        const value = metric[key2];
+        if (typeof value === "string") push(at2("metric", key2), value, "metric", "metric");
       }
     const timeline = node.timeline, events = Array.isArray(timeline) ? timeline : Array.isArray(rec(timeline).events) ? rec(timeline).events : [];
     if (typeof rec(timeline).name === "string") push(at2("timeline", "name"), rec(timeline).name, "timeline", "timeline");
@@ -1595,8 +1702,8 @@ var contrastRules = [
             }
             continue;
           }
-          const key = `${sample.source === "default" ? "default" : sample.path}|${sample.color}|${worst.against}|${large}`;
-          const known = aggregated.get(key);
+          const key2 = `${sample.source === "default" ? "default" : sample.path}|${sample.color}|${worst.against}|${large}`;
+          const known = aggregated.get(key2);
           if (known && sample.source === "default") {
             known.extra++;
             continue;
@@ -1617,7 +1724,7 @@ var contrastRules = [
             measured: { ratio: round(worst.ratio), needed, large, sizePt: round(sample.sizePx * PX_TO_PT), textColor: sample.color, backgroundColor: worst.against },
             fixes
           });
-          if (sample.source === "default") aggregated.set(key, { diagnostic, extra: 0 });
+          if (sample.source === "default") aggregated.set(key2, { diagnostic, extra: 0 });
         }
         for (const { diagnostic, extra } of aggregated.values())
           if (extra) {
@@ -1893,7 +2000,7 @@ var chartColorRule = rule(
   {
     standard: "WCAG 2.2 SC 1.4.1 Use of Color, level A",
     thresholds: ["minSeriesColorDifference"],
-    approximations: "Uses the engine's series palette (ValidateOptions.chartPalette; default the opf-render/opf-pptx palette, adjusted for the card surface like the preview does) in series order: series i takes colour i, pie/doughnut/treemap/funnel slices take colours per category. Pairs are compared by CIE76 distance after simulating protanopia, deuteranopia, tritanopia (Machado 2009, severity 1) and greyscale. Single-series charts and chart types without a series legend are skipped."
+    approximations: "Uses the engine's series palette (ValidateOptions.chartPalette; default chartSeriesPalette of each slide colour scheme (accent1 to accent6, then their tints), adjusted for the card surface like the preview does) in series order: series i takes colour i, pie/doughnut/treemap/funnel slices take colours per category. Pairs are compared by CIE76 distance after simulating protanopia, deuteranopia, tritanopia (Machado 2009, severity 1) and greyscale. Single-series charts and chart types without a series legend are skipped."
   }
 );
 var chartAltRule = rule(
@@ -1904,6 +2011,21 @@ var chartAltRule = rule(
   "A chart conveys a message; people who cannot see it need the message and ideally the numbers in text. The chart's alt field is that text alternative (the preview exposes it as the chart's accessible name and the PowerPoint export writes it as the frame's alternative text); a sentence or table beside the chart also serves. An empty alt marks a chart decorative, which is reported as info so the choice is reviewed: a chart rarely carries no message.",
   { standard: "WCAG 2.2 SC 1.1.1 Non-text Content, level A", approximations: `A chart passes when chart.alt has text. Without alt, it passes when the slide has any other text, list, table, quote or metric content besides title and tag, or a subtitle. It does not judge whether alt or that text states the chart's point (see opf/poor-alt-text for generic alt text). alt: "" is reported as a decorative chart, whatever else is on the slide.` }
 );
+var chartColorsRule = rule(
+  "chart-colors-adjusted",
+  "accessibility",
+  "warning",
+  "A chart colour cannot be used as authored.",
+  "`chart.colors` sets the colour of series 1, 2, 3 and so on. A colour that cannot be resolved (a `var:` colour variable the deck does not define, or a name that is not a colour) is ignored and the deck palette colour of that position is used. A colour with under 3:1 contrast against the chart panel is kept for its hue but drawn lighter or darker, so the chart does not show the colour that was written.",
+  {
+    standard: "WCAG 2.2 SC 1.4.11 Non-text Contrast, level AA",
+    approximations: "Resolves each entry like any colour reference (hex, colour-scheme slot or role, `var:` variable) against the slide's scheme and compares it with the chart panel (the slide surface colour) by WCAG contrast; 3:1 is the threshold the engines enforce. Translucent colours and unresolved panels are not measured. Colours that look alike to colour-vision deficiency are reported by opf/chart-color-only, which judges the authored colours."
+  }
+);
+var chartColorContext = (design) => ({
+  roles: { primary: design.colors.primary, secondary: design.colors.secondary, accent: design.colors.accent, background: design.colors.background, surface: design.colors.surface, text: design.colors.text, textSecondary: design.colors.mutedText },
+  variables: design.variables
+});
 var chartSkip = /(histogram|box|pareto|waterfall|world|map)/;
 var perCategory = /(pie|doughnut|treemap|funnel)/;
 var chartRules = [
@@ -1922,7 +2044,7 @@ var chartRules = [
           const count = slices ? data.rows.length : data.columns.length - 1;
           if (count < 2) continue;
           const surface = slide.design.colors.surface;
-          const palette = chartPaletteForFill(surface, context.chartPalette);
+          const palette = chartPaletteForFill(surface, context.chartPalette ?? chartSeriesPalette(slide.design.colorScheme, chart.colors, chartColorContext(slide.design)));
           if (!palette.length) continue;
           const used = Array.from({ length: Math.min(count, 24) }, (_, i) => palette[i % palette.length]);
           const pairs = [];
@@ -1939,17 +2061,51 @@ var chartRules = [
           if (!pairs.length && !cycles) continue;
           pairs.sort((x, y) => x.difference - y.difference);
           const names2 = slices ? data.rows.map((row) => String(row?.[0] ?? "")) : data.columns.slice(1).map(String);
-          const describe = (p) => `${JSON.stringify(names2[p.a] ?? `#${p.a + 1}`)} and ${JSON.stringify(names2[p.b] ?? `#${p.b + 1}`)} (${p.model}, difference ${p.difference.toFixed(1)})`;
+          const describe2 = (p) => `${JSON.stringify(names2[p.a] ?? `#${p.a + 1}`)} and ${JSON.stringify(names2[p.b] ?? `#${p.b + 1}`)} (${p.model}, difference ${p.difference.toFixed(1)})`;
           context.report(chartColorRule, {
             path: `${payload.path === slide.path ? slide.path : payload.path}/chart`,
             slide,
-            message: `${slices ? "Slices" : "Series"} may be hard to tell apart without colour: ${pairs.slice(0, 3).map(describe).join("; ")}${cycles ? `${pairs.length ? "; " : ""}${count} ${slices ? "slices" : "series"} exceed the ${palette.length}-colour palette, so colours repeat` : ""}.`,
+            message: `${slices ? "Slices" : "Series"} may be hard to tell apart without colour: ${pairs.slice(0, 3).map(describe2).join("; ")}${cycles ? `${pairs.length ? "; " : ""}${count} ${slices ? "slices" : "series"} exceed the ${palette.length}-colour palette, so colours repeat` : ""}.`,
             help: "Show fewer series per chart (split into two charts), state the key values in the slide text or a table next to the chart, or choose a chart type whose categories sit on an axis instead of in a legend.",
             measured: { series: count, confusablePairs: pairs.length, minDifference: pairs[0] ? round(pairs[0].difference) : null }
           });
         }
     }
   },
+  {
+    info: chartColorsRule,
+    run(context) {
+      for (const slide of context.slides)
+        for (const payload of slidePayloads(slide.slide, slide.path)) {
+          const chart = rec(payload.node.chart);
+          if (!Array.isArray(chart.colors)) continue;
+          const surface = normalizeHexColor(slide.design.colors.surface);
+          const resolved = resolveChartColors(chart.colors, slide.design.colorScheme, chartColorContext(slide.design));
+          resolved.forEach((color, index) => {
+            const path = `${payload.path === slide.path ? slide.path : payload.path}/chart/colors/${index}`;
+            const entry = chart.colors[index];
+            if (color === void 0) {
+              context.report(chartColorsRule, {
+                path,
+                slide,
+                message: `Chart colour ${index + 1} (${JSON.stringify(entry)}) cannot be resolved, so the palette colour of that position is used.`,
+                help: 'Use a hex colour, a colour-scheme name such as "accent2", or the id of a colour variable the deck defines (var:<id>).'
+              });
+              return;
+            }
+            const contrast = surface ? colorContrast(color, surface) : void 0;
+            if (contrast === void 0 || contrast >= 3) return;
+            context.report(chartColorsRule, {
+              path,
+              slide,
+              message: `Chart colour ${index + 1} (${color}) has ${contrast.toFixed(1)}:1 contrast against the chart panel (${surface}); it is drawn lighter or darker to reach 3:1.`,
+              help: "Choose a colour that already has at least 3:1 contrast against the slide surface, so the chart shows the colour you wrote.",
+              measured: { contrast: round(contrast), panel: surface }
+            });
+          });
+        }
+    }
+  },
   {
     info: chartAltRule,
     run(context) {
@@ -2208,9 +2364,9 @@ var layoutRules = [
         for (const { diagnostic } of slide.layoutDiagnostics) {
           const path = pointerOfDotted(diagnostic.path);
           if (!path.startsWith("/slides/")) {
-            const key = `${diagnostic.code}|${path}|${diagnostic.message}`;
-            if (deckLevel.has(key)) continue;
-            deckLevel.add(key);
+            const key2 = `${diagnostic.code}|${path}|${diagnostic.message}`;
+            if (deckLevel.has(key2)) continue;
+            deckLevel.add(key2);
           }
           if (diagnostic.code === "text-overflow")
             context.report(overflowRule, { path, slide, message: diagnostic.message, help: "Shorten the text, give it more space (fewer blocks, a different composition) or split the slide (paginate); raising the readable minimum makes it worse." });
@@ -2648,7 +2804,7 @@ function ruleInfo(id) {
 }
 
 // src/check-document.ts
-var own = (value, key) => Object.hasOwn(value, key);
+var own = (value, key2) => Object.hasOwn(value, key2);
 var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var primitive = (value) => value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
 var pointer3 = (parts2) => parts2.length ? "/" + parts2.map((part) => String(part).replaceAll("~", "~0").replaceAll("/", "~1")).join("/") : "";
@@ -2660,7 +2816,7 @@ function parts(path) {
 }
 function at(value, path) {
   return parts(path).reduce(
-    (current, key) => object(current) || Array.isArray(current) ? own(current, key) ? current[key] : void 0 : void 0,
+    (current, key2) => object(current) || Array.isArray(current) ? own(current, key2) ? current[key2] : void 0 : void 0,
     value
   );
 }
@@ -2670,13 +2826,13 @@ function checkDocumentOptions(options) {
     throw new TypeError("Validate contracts must be an array.");
   for (const contract of options.contracts ?? []) {
     if (!object(contract) || Object.keys(contract).some(
-      (key) => ![
+      (key2) => ![
         "path",
         "allowedValues",
         "severity",
         "message",
         "documentation"
-      ].includes(key)
+      ].includes(key2)
     ) || typeof contract.path !== "string" || !Array.isArray(contract.allowedValues) || !contract.allowedValues.every(primitive) || contract.severity !== void 0 && (typeof contract.severity !== "string" || !["error", "warning", "info"].includes(contract.severity)) || contract.message !== void 0 && typeof contract.message !== "string" || contract.documentation !== void 0 && typeof contract.documentation !== "string")
       throw new TypeError(
         "Invalid contract: provide a path and primitive allowedValues, with optional severity, message and documentation."
@@ -2754,13 +2910,13 @@ function score(schema, value) {
   if (own(schema, "const")) return schema.const === value ? 100 : -1e4;
   let result = 1;
   if (object(value) && object(schema.properties)) {
-    for (const [key, child] of Object.entries(schema.properties))
-      if (own(value, key) && object(child))
-        result += own(child, "const") ? child.const === value[key] ? 100 : -1e3 : 1;
+    for (const [key2, child] of Object.entries(schema.properties))
+      if (own(value, key2) && object(child))
+        result += own(child, "const") ? child.const === value[key2] ? 100 : -1e3 : 1;
   }
   if (Array.isArray(schema.required)) {
-    for (const key of schema.required)
-      if (typeof key === "string" && (!object(value) || !own(value, key)))
+    for (const key2 of schema.required)
+      if (typeof key2 === "string" && (!object(value) || !own(value, key2)))
         result -= 2;
   }
   return result;
@@ -2782,7 +2938,7 @@ function active(cursor, value) {
   const selected = candidates.sort((a, b) => score(b.schema, value) - score(a.schema, value))[0];
   return selected ? { ...selected, baseSchemas: [...selected.baseSchemas ?? [], resolved] } : resolved;
 }
-function childCursor(cursors, key) {
+function childCursor(cursors, key2) {
   for (const keyword of [
     "properties",
     "patternProperties",
@@ -2791,8 +2947,8 @@ function childCursor(cursors, key) {
     for (const cursor of cursors) {
       const declarations = cursor.schema[keyword];
       if (!object(declarations)) continue;
-      const name = keyword === "properties" ? key : keyword === "patternProperties" ? Object.keys(declarations).find(
-        (pattern) => new RegExp(pattern).test(key)
+      const name = keyword === "properties" ? key2 : keyword === "patternProperties" ? Object.keys(declarations).find(
+        (pattern) => new RegExp(pattern).test(key2)
       ) : void 0;
       const schema = keyword === "additionalProperties" ? declarations : name === void 0 ? void 0 : declarations[name];
       if (object(schema))
@@ -2851,13 +3007,13 @@ function fields(document) {
         });
       });
     else if (object(entry.value))
-      for (const [key, value] of Object.entries(entry.value)) {
-        if (entry.path.length === 0 && key === "catalogs") continue;
-        const cursor = childCursor(cursors, key);
+      for (const [key2, value] of Object.entries(entry.value)) {
+        if (entry.path.length === 0 && key2 === "catalogs") continue;
+        const cursor = childCursor(cursors, key2);
         if (!cursor) continue;
         stack.push({
           value,
-          path: [...entry.path, key],
+          path: [...entry.path, key2],
           cursor,
           ancestors
         });
@@ -3003,8 +3159,8 @@ function variableFindings(document, engine, schemaValid) {
       })
     );
   if (engine.template !== void 0 || !schemaValid) return findings;
-  const walk = (value, path, depth) => {
-    if (depth > 64) return;
+  const walk = (value, path, depth2) => {
+    if (depth2 > 64) return;
     if (typeof value === "string") {
       if (value.startsWith("data:") || !value.includes("{{")) return;
       for (const match of value.matchAll(VARIABLE_TOKEN))
@@ -3021,14 +3177,14 @@ function variableFindings(document, engine, schemaValid) {
     }
     if (Array.isArray(value)) {
       value.forEach((entry, index) => {
-        walk(entry, [...path, String(index)], depth + 1);
+        walk(entry, [...path, String(index)], depth2 + 1);
       });
       return;
     }
     if (value && typeof value === "object")
-      for (const [key, entry] of Object.entries(value)) {
-        if (path.length === 0 && ["variables", "extensions", "catalogs", "assets"].includes(key)) continue;
-        walk(entry, [...path, key], depth + 1);
+      for (const [key2, entry] of Object.entries(value)) {
+        if (path.length === 0 && ["variables", "extensions", "catalogs", "assets"].includes(key2)) continue;
+        walk(entry, [...path, key2], depth2 + 1);
       }
   };
   walk(document, [], 0);
@@ -3223,7 +3379,7 @@ function contractFindings(document, contracts) {
         };
         const message = (contract.message ?? "This value is outside the allowed values for {{path}}.").replace(
           /\{\{(path|value|allowed|file)\}\}/g,
-          (_, key) => values[key] ?? ""
+          (_, key2) => values[key2] ?? ""
         );
         findings.push(
           finding("opf/contract", {
@@ -3241,9 +3397,9 @@ function contractFindings(document, contracts) {
           })
         );
       } else if (object(entry.value) || Array.isArray(entry.value)) {
-        const key = pattern[entry.depth];
+        const key2 = pattern[entry.depth];
         for (const [name, value] of Object.entries(entry.value))
-          if (key === "*" || key === name)
+          if (key2 === "*" || key2 === name)
             stack.push({
               value,
               path: [...entry.path, name],
@@ -3316,18 +3472,18 @@ function parseSource(source) {
     if (node.type === "object") {
       const keys = /* @__PURE__ */ new Set();
       for (const property of node.children ?? []) {
-        const key = property.children?.[0];
-        if (!key) continue;
-        if (keys.has(key.value))
+        const key2 = property.children?.[0];
+        if (!key2) continue;
+        if (keys.has(key2.value))
           duplicates.push(
             finding("opf/duplicate-key", {
-              path: pointer3(getNodePath(key)),
-              message: `Duplicate JSON property ${JSON.stringify(key.value)}.`,
+              path: pointer3(getNodePath(key2)),
+              message: `Duplicate JSON property ${JSON.stringify(key2.value)}.`,
               help: "Resolve the duplicate explicitly, preserving the intended content from both occurrences. JSON.parse would otherwise hide an earlier value.",
-              location: location(key.offset, key.length)
+              location: location(key2.offset, key2.length)
             })
           );
-        keys.add(key.value);
+        keys.add(key2.value);
       }
     }
     stack.push(...node.children ?? []);
@@ -3368,7 +3524,7 @@ function scriptProfile(presentation, slideIndex, options, language) {
   }
   const slots = (role) => {
     const latin = options.fontFamilies[role];
-    const slot = (key) => !resolved || resolved.sources[key] === "latin" || resolved.sources[key] === "schemeFamily" ? latin : resolved[role][key] ?? latin;
+    const slot = (key2) => !resolved || resolved.sources[key2] === "latin" || resolved.sources[key2] === "schemeFamily" ? latin : resolved[role][key2] ?? latin;
     return { latin, eastAsian: slot("eastAsian"), complexScript: slot("complexScript") };
   };
   return {
@@ -3588,7 +3744,7 @@ function names(list, what) {
 }
 function resolveOptions(options) {
   if (!isObject(options)) throw new TypeError("Validate options must be an object.");
-  for (const key of Object.keys(options)) if (!OPTION_KEYS.includes(key)) throw new TypeError(`Unknown validate option ${JSON.stringify(key)}. Options: ${OPTION_KEYS.join(", ")}.`);
+  for (const key2 of Object.keys(options)) if (!OPTION_KEYS.includes(key2)) throw new TypeError(`Unknown validate option ${JSON.stringify(key2)}. Options: ${OPTION_KEYS.join(", ")}.`);
   checkDocumentOptions(options);
   const only = names(options.only, "only");
   const ignore = names(options.ignore, "ignore");
@@ -3617,10 +3773,10 @@ function resolveOptions(options) {
   const thresholds = { ...DEFAULT_VALIDATION_THRESHOLDS };
   if (options.thresholds !== void 0) {
     if (!isObject(options.thresholds)) throw new TypeError("Validate thresholds must be an object.");
-    for (const [key, value] of Object.entries(options.thresholds)) {
-      if (!(key in DEFAULT_VALIDATION_THRESHOLDS)) throw new TypeError(`Unknown validate threshold ${JSON.stringify(key)}. Thresholds: ${Object.keys(DEFAULT_VALIDATION_THRESHOLDS).join(", ")}.`);
-      if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new TypeError(`Validate threshold ${key} must be a positive number.`);
-      thresholds[key] = value;
+    for (const [key2, value] of Object.entries(options.thresholds)) {
+      if (!(key2 in DEFAULT_VALIDATION_THRESHOLDS)) throw new TypeError(`Unknown validate threshold ${JSON.stringify(key2)}. Thresholds: ${Object.keys(DEFAULT_VALIDATION_THRESHOLDS).join(", ")}.`);
+      if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new TypeError(`Validate threshold ${key2} must be a positive number.`);
+      thresholds[key2] = value;
     }
   }
   if (options.fonts !== void 0) {
@@ -3644,7 +3800,7 @@ function resolveOptions(options) {
     },
     ignored: (info, path) => ignorePaths.some((entry) => entry.match(info) && entry.path.every((part, index) => path[index] === part)),
     thresholds,
-    chartPalette: options.chartPalette ?? DEFAULT_CHART_PALETTE
+    chartPalette: options.chartPalette
   };
 }
 var order = new Map(validationRules.map((info, index) => [info.id, index]));
@@ -3824,4 +3980,4 @@ function assertValidCatalogRecord(kind, value) {
   if (!report2.valid) throw new OPFValidationError(report2);
 }
 
-export { CATALOG_SCHEMA, DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogSchemaNames, findValidationRule, parseSource, resolveSlideContext, resolveSlideScriptMeasurement, validate, validateCatalogRecord, validationCategories, validationRules };
+export { CATALOG_SCHEMA, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogSchemaNames, findValidationRule, parseSource, resolveSlideContext, resolveSlideScriptMeasurement, validate, validateCatalogRecord, validationCategories, validationRules };