@openpresentation/opf 0.11.4 → 0.12.0

package/dist/chunk-JENJZR3F.js

@@ -0,0 +1,1690 @@
+import { lintSource } from './chunk-JVTN3HPP.js';
+import { validatePresentation } from './chunk-UQKJWHSS.js';
+import { chartPaletteForFill, tableGrid, readingRows, visualReadingOrder, visitContentPayloads, intrinsicImageSize, textWidthMeasurer, normalizeHexColor, resolveColorRef, resolveScriptFonts, OPFCompositionError, resolveFontSchemeReference, DEFAULT_FONT_SCHEME, resolveCanvasDimensions, resolveFontFamilies, composeSlide } from './chunk-6TSDIPSH.js';
+import { catalogs } from './chunk-3ZGSWEHK.js';
+import { parseTree } from 'jsonc-parser';
+
+// src/audit-context.ts
+var rule = (id, category, severity, summary, rationale, extra = {}) => ({ id: `audit/${id}`, name: id, category, severity, summary, rationale, ...extra });
+
+// src/audit-design.ts
+var rec = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var toRgb = (hex) => {
+  const n = normalizeHexColor(hex) ?? "#000000";
+  return [1, 3, 5].map((at) => Number.parseInt(n.slice(at, at + 2), 16));
+};
+var toHex = (rgb) => `#${rgb.map((c) => Math.max(0, Math.min(255, Math.round(c))).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
+var linear = (c) => {
+  const n = c / 255;
+  return n <= 0.04045 ? n / 12.92 : ((n + 0.055) / 1.055) ** 2.4;
+};
+var delinear = (c) => {
+  const v = Math.max(0, Math.min(1, c));
+  return 255 * (v <= 31308e-7 ? v * 12.92 : 1.055 * v ** (1 / 2.4) - 0.055);
+};
+function blend(fg, bg, alpha) {
+  const a = Math.max(0, Math.min(1, alpha)), f = toRgb(fg), b = toRgb(bg);
+  return toHex(f.map((c, i) => c * a + (b[i] ?? 0) * (1 - a)));
+}
+var relativeLuminance = (hex) => {
+  const [r, g, b] = toRgb(hex);
+  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
+};
+function contrastRatio(a, b) {
+  const x = relativeLuminance(a), y = relativeLuminance(b);
+  return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
+}
+function lab(hex) {
+  const [r, g, b] = toRgb(hex).map(linear);
+  const x = (0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / 0.95047, y = 0.2126729 * r + 0.7151522 * g + 0.072175 * b, z = (0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883;
+  const f = (t) => t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
+  const fx = f(x), fy = f(y), fz = f(z);
+  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
+}
+function colorDifference(a, b) {
+  const [l1, a1, b1] = lab(a), [l2, a2, b2] = lab(b);
+  return Math.hypot(l1 - l2, a1 - a2, b1 - b2);
+}
+var CVD_MATRICES = {
+  // Machado, Oliveira and Fernandes (2009), severity 1.0, applied to linear sRGB.
+  protanopia: [
+    [0.152286, 1.052583, -0.204868],
+    [0.114503, 0.786281, 0.099216],
+    [-3882e-6, -0.048116, 1.051998]
+  ],
+  deuteranopia: [
+    [0.367322, 0.860646, -0.227968],
+    [0.280085, 0.672501, 0.047413],
+    [-0.01182, 0.04294, 0.968881]
+  ],
+  tritanopia: [
+    [1.255528, -0.076749, -0.178779],
+    [-0.078411, 0.930809, 0.147602],
+    [4733e-6, 0.691367, 0.3039]
+  ]
+};
+var visionModels = ["protanopia", "deuteranopia", "tritanopia", "greyscale"];
+function simulateVision(hex, model) {
+  const rgb = toRgb(hex).map(linear);
+  if (model === "greyscale") {
+    const y = 0.2126 * (rgb[0] ?? 0) + 0.7152 * (rgb[1] ?? 0) + 0.0722 * (rgb[2] ?? 0);
+    const v = delinear(y);
+    return toHex([v, v, v]);
+  }
+  const m = CVD_MATRICES[model];
+  return toHex(m.map((row) => delinear(row[0] * (rgb[0] ?? 0) + row[1] * (rgb[1] ?? 0) + row[2] * (rgb[2] ?? 0))));
+}
+function createLookup(document, extra) {
+  return (kind, id) => {
+    const inline = rec(rec(document.catalogs)[kind]).records;
+    const found = (Array.isArray(inline) ? inline : []).find((r) => r?.id === id) ?? (extra?.[kind] ?? []).find((r) => rec(r).id === id) ?? catalogs[kind]?.find((r) => rec(r).id === id);
+    return found === void 0 ? void 0 : rec(found);
+  };
+}
+function resolveReference(kind, reference, lookup) {
+  if (typeof reference === "string") return lookup(kind, reference) ?? {};
+  if (reference && typeof reference === "object" && !Array.isArray(reference)) {
+    const id = reference.id;
+    return { ...typeof id === "string" ? lookup(kind, id) : void 0, ...reference };
+  }
+  return {};
+}
+var PAGE = "#FFFFFF";
+var colorFrom = (scheme, slot, fallback) => typeof slot === "string" ? slot.startsWith("#") ? normalizeHexColor(slot) ?? fallback : normalizeHexColor(scheme[slot]) ?? fallback : fallback;
+function backdropOf(definition, scheme, text) {
+  const resolve = (value, fallback) => normalizeHexColor(value) ?? fallback;
+  if (!definition) return { kind: "solid", color: colorFrom(scheme, "light1", PAGE) };
+  if (typeof definition === "string") return { kind: "solid", color: colorFrom(scheme, definition, PAGE) };
+  const bg = rec(definition), opacity = typeof bg.opacity === "number" ? Math.max(0, Math.min(1, bg.opacity)) : 1;
+  switch (bg.type) {
+    case "theme":
+      return { kind: "solid", color: blend(colorFrom(scheme, bg.slot, PAGE), PAGE, opacity) };
+    case "solid":
+      return { kind: "solid", color: blend(resolve(bg.color, PAGE), PAGE, opacity) };
+    case "gradient": {
+      const stops = Array.isArray(rec(bg.gradient).stops) ? rec(bg.gradient).stops : [];
+      return {
+        kind: "gradient",
+        angle: Number(rec(bg.gradient).angle ?? 0),
+        stops: stops.map((stop, index) => ({
+          color: blend(resolve(stop.color, colorFrom(scheme, "light1", PAGE)), PAGE, opacity),
+          position: typeof stop.position === "number" ? stop.position : index / Math.max(1, stops.length - 1)
+        }))
+      };
+    }
+    case "pattern": {
+      const pattern = rec(bg.pattern);
+      return {
+        kind: "pattern",
+        colors: [
+          blend(resolve(pattern.backgroundColor, PAGE), PAGE, opacity),
+          blend(resolve(pattern.foregroundColor, text), PAGE, opacity)
+        ]
+      };
+    }
+    case "image":
+      return { kind: "image", opacity, base: PAGE };
+    default:
+      return { kind: "solid", color: colorFrom(scheme, "light1", PAGE) };
+  }
+}
+function decisionColor(definition, scheme) {
+  if (!definition) return colorFrom(scheme, "light1", PAGE);
+  if (typeof definition === "string") return colorFrom(scheme, definition, PAGE);
+  const bg = rec(definition);
+  switch (bg.type) {
+    case "theme":
+      return colorFrom(scheme, bg.slot, PAGE);
+    case "solid":
+      return normalizeHexColor(bg.color) ?? PAGE;
+    case "pattern":
+      return normalizeHexColor(rec(bg.pattern).backgroundColor) ?? PAGE;
+    case "gradient":
+      return PAGE;
+    default:
+      return colorFrom(scheme, "light1", PAGE);
+  }
+}
+function resolveDesign(document, slide, index, lookup) {
+  const deck = rec(document.design), own = rec(slide.design);
+  const theme = resolveReference("themes", own.theme ?? deck.theme ?? "minimal", lookup);
+  const colorScheme = resolveReference(
+    "colorSchemes",
+    own.colorScheme ?? deck.colorScheme ?? theme.colorScheme ?? "cool-horizon",
+    lookup
+  );
+  const fontPath = own.fontScheme !== void 0 ? `/slides/${index}/design/fontScheme` : deck.fontScheme !== void 0 ? "/design/fontScheme" : own.theme !== void 0 ? `/slides/${index}/design/theme` : "/design/theme";
+  const font = resolveFontSchemeReference(
+    own.fontScheme ?? deck.fontScheme ?? theme.fontScheme ?? DEFAULT_FONT_SCHEME,
+    (id) => lookup("fontSchemes", id),
+    fontPath
+  );
+  let dimensions;
+  try {
+    dimensions = resolveCanvasDimensions(own.dimensions ?? deck.dimensions ?? theme.dimensions);
+  } catch {
+    dimensions = resolveCanvasDimensions(void 0);
+  }
+  const variables = rec(document.variables);
+  const backgroundColor = decisionColor(own.background ?? deck.background ?? theme.background, colorScheme);
+  const dark = relativeLuminance(backgroundColor) < 0.179;
+  const text = colorFrom(colorScheme, dark ? "light1" : "dark1", dark ? "#FFFFFF" : "#111827");
+  const backdrop = backdropOf(own.background ?? deck.background ?? theme.background, colorScheme, text);
+  const definition = rec(own.background ?? deck.background ?? theme.background);
+  const backgroundImage = definition.type === "image" && own.background !== void 0 ? { source: rec(definition.image).src, fit: rec(definition.image).fit ?? "cover", path: `/slides/${index}/design/background/image` } : definition.type === "image" && deck.background !== void 0 ? { source: rec(definition.image).src, fit: rec(definition.image).fit ?? "cover", path: "/design/background/image" } : void 0;
+  return {
+    theme,
+    colorScheme,
+    fontScheme: font.scheme,
+    fonts: resolveFontFamilies(font.scheme),
+    dimensions,
+    backdrop,
+    dark,
+    colors: {
+      background: colorFrom(colorScheme, "light1", PAGE),
+      surface: colorFrom(colorScheme, dark ? "dark2" : "light2", dark ? "#1E293B" : "#F8FAFC"),
+      text,
+      mutedText: colorFrom(colorScheme, dark ? "light2" : "dark2", dark ? "#E2E8F0" : "#334155"),
+      primary: normalizeHexColor(colorScheme.primary) ?? colorFrom(colorScheme, "accent1", "#2563EB"),
+      secondary: normalizeHexColor(colorScheme.secondary) ?? colorFrom(colorScheme, "accent2", "#0F766E"),
+      accent: normalizeHexColor(colorScheme.accent) ?? colorFrom(colorScheme, "accent3", "#F59E0B")
+    },
+    variables,
+    ...backgroundImage ? { backgroundImage } : {},
+    fontSchemePath: fontPath,
+    ...font.diagnostic ? { unresolvedFontScheme: font.diagnostic.id } : {}
+  };
+}
+function resolveTextColor(reference, design, fallback) {
+  if (typeof reference !== "string" || !reference.trim()) return void 0;
+  const literal = normalizeHexColor(reference);
+  if (literal) return literal;
+  return resolveColorRef(reference.trim(), {
+    colorScheme: design.colorScheme,
+    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,
+    fallback
+  });
+}
+var GREY_RAMP = [0, 32, 64, 96, 128, 160, 192, 224, 255].map((v) => toHex([v, v, v]));
+function backdropColors(backdrop, box, size, layer) {
+  switch (backdrop.kind) {
+    case "solid":
+      return { colors: [backdrop.color], unknown: false };
+    case "pattern":
+      return { colors: [...backdrop.colors], unknown: false };
+    case "gradient": {
+      const stops = [...backdrop.stops].sort((a, b) => a.position - b.position);
+      if (!stops.length) return { colors: [PAGE], unknown: false };
+      const angle = backdrop.angle * Math.PI / 180, c = Math.cos(angle), s = Math.sin(angle), region = box ?? { x: 0, y: 0, width: size.width, height: size.height };
+      const colors = /* @__PURE__ */ new Set();
+      for (let i = 0; i <= 4; i++)
+        for (let j = 0; j <= 4; j++) {
+          const px = (region.x + region.width * i / 4) / size.width, py = (region.y + region.height * j / 4) / size.height, t = Math.max(0, Math.min(1, 0.5 + (px - 0.5) * c + (py - 0.5) * s));
+          const after = stops.findIndex((stop) => stop.position >= t);
+          if (after <= 0) colors.add(stops[Math.max(0, after)]?.color ?? PAGE);
+          else {
+            const lo = stops[after - 1], hi = stops[after], span = hi.position - lo.position || 1;
+            colors.add(blend(hi.color, lo.color, (t - lo.position) / span));
+          }
+        }
+      return { colors: [...colors], unknown: false };
+    }
+    case "image": {
+      const opacity = layer?.opacity ?? backdrop.opacity;
+      const colors = GREY_RAMP.map((grey) => {
+        let color = blend(grey, backdrop.base, opacity);
+        if (layer?.overlay) color = blend(layer.overlay.color, color, layer.overlay.opacity);
+        return color;
+      });
+      return { colors, unknown: true };
+    }
+  }
+}
+function worstContrast(text, sample) {
+  let worst = { ratio: Infinity, against: sample.colors[0] ?? PAGE };
+  for (const color of sample.colors) {
+    const ratio = contrastRatio(text, color);
+    if (ratio < worst.ratio) worst = { ratio, against: color };
+  }
+  return worst;
+}
+function readableColor(candidates, sample, minimum) {
+  for (const candidate of [...candidates, "#000000", "#FFFFFF"])
+    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/audit-content.ts
+var pointer = (...parts) => parts.length ? "/" + parts.map((part) => String(part).replaceAll("~", "~0").replaceAll("/", "~1")).join("/") : "";
+var pointerOfDotted = (path) => "/" + path.split(".").map((part) => part.replaceAll("~", "~0").replaceAll("/", "~1")).join("/");
+function slidePayloads(slide, slidePath) {
+  const out = [{ path: slidePath, node: slide, root: true }];
+  visitContentPayloads(slide, slidePath, (node, path) => out.push({ path, node, root: false }));
+  return out;
+}
+var isText = (value) => typeof value === "string" || Array.isArray(value);
+function textValues(slide, slidePath) {
+  const out = [];
+  for (const field of ["title", "subtitle", "tag"])
+    if (typeof slide[field] === "string") out.push({ path: pointer(...splitPointer(slidePath), field), value: slide[field], role: field, payload: slidePath, field });
+  for (const payload of slidePayloads(slide, slidePath)) {
+    const node = payload.node, at = (...tail) => pointer(...splitPointer(payload.path), ...tail);
+    const push = (path, value, role, field) => {
+      if (isText(value)) out.push({ path, value, role, payload: payload.path, field });
+    };
+    push(at("text"), node.text, "body", "text");
+    for (const field of ["items", "bullets"])
+      if (Array.isArray(node[field]))
+        node[field].forEach((entry, index) => {
+          if (isText(entry)) push(at(field, index), entry, "list", field);
+          else if (entry && typeof entry === "object") {
+            push(at(field, index, "text"), entry.text, "list", field);
+            push(at(field, index, "description"), entry.description, "list-description", field);
+          }
+        });
+    const table = rec(node.table);
+    if (Array.isArray(table.columns))
+      table.columns.forEach((cell, c) => {
+        const styled = rec(cell);
+        const value = Object.hasOwn(styled, "value") ? styled.value : cell;
+        push(at("table", "columns", c, ...Object.hasOwn(styled, "value") ? ["value"] : []), value, "table-header", "table");
+      });
+    if (Array.isArray(table.rows))
+      table.rows.forEach((row, r) => {
+        if (!Array.isArray(row)) return;
+        row.forEach((cell, c) => {
+          const styled = rec(cell);
+          const value = Object.hasOwn(styled, "value") ? styled.value : cell;
+          push(at("table", "rows", r, c, ...Object.hasOwn(styled, "value") ? ["value"] : []), value, "table", "table");
+        });
+      });
+    const quote = node.quote;
+    if (typeof quote === "string") push(at("quote"), quote, "quote", "quote");
+    else if (quote && typeof quote === "object") {
+      push(at("quote", "text"), quote.text, "quote", "quote");
+      push(at("quote", "attribution"), quote.attribution, "quote-footer", "quote");
+      push(at("quote", "source"), quote.source, "quote-footer", "quote");
+    }
+    const metric = node.metric;
+    if (typeof metric === "string") push(at("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(at("metric", key), 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(at("timeline", "name"), rec(timeline).name, "timeline", "timeline");
+    events.forEach((event, index) => {
+      const base = Array.isArray(timeline) ? ["timeline", index] : ["timeline", "events", index];
+      push(at(...base, "when"), event?.when, "timeline", "timeline");
+      push(at(...base, "what"), event?.what, "timeline", "timeline");
+    });
+  }
+  return out;
+}
+function splitPointer(path) {
+  return path === "" ? [] : path.slice(1).split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+var plainText = (value) => typeof value === "string" ? value : value.map((run) => typeof run === "string" ? run : typeof rec(run).text === "string" ? rec(run).text : "").join("");
+function runsOf(tv) {
+  if (typeof tv.value === "string") return [{ path: tv.path, text: tv.value, style: {}, index: -1, valuePath: tv.path }];
+  return tv.value.map((run, index) => ({
+    path: pointer(...splitPointer(tv.path), index),
+    text: typeof run === "string" ? run : typeof rec(run).text === "string" ? rec(run).text : "",
+    style: typeof run === "string" ? {} : rec(run),
+    index,
+    valuePath: tv.path
+  }));
+}
+var segmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "word" }) : void 0;
+function countWords(text) {
+  if (segmenter) {
+    let count = 0;
+    for (const part of segmenter.segment(text)) if (part.isWordLike) count++;
+    return count;
+  }
+  return text.split(/\s+/).filter((word) => /[\p{L}\p{N}]/u.test(word)).length;
+}
+function altOf(value, assets) {
+  const own = typeof value === "object" && value !== null ? value.alt : void 0;
+  if (typeof own === "string") return own;
+  let source = typeof value === "string" ? value : rec(value).src;
+  for (let hop = 0; typeof source === "string" && source.startsWith("asset:") && hop < 8; hop++) {
+    const entry = rec(assets)[source.slice(6)];
+    if (typeof rec(entry).alt === "string") return rec(entry).alt;
+    source = typeof entry === "string" ? entry : rec(entry).src;
+  }
+  return void 0;
+}
+var sourceOfAsset = (value) => {
+  const source = typeof value === "string" ? value : rec(value).src;
+  return typeof source === "string" ? source : void 0;
+};
+var LOGO_VARIANTS = ["default", "light", "dark", "stacked", "stackedLight", "stackedDark", "icon", "iconLight", "iconDark", "wordmark", "wordmarkLight", "wordmarkDark"];
+function assetRefs(document, slide, slidePath, includeDeck) {
+  const out = [];
+  for (const payload of slidePayloads(slide, slidePath)) {
+    const at = (...tail) => pointer(...splitPointer(payload.path), ...tail);
+    if (payload.node.image !== void 0) out.push({ path: at("image"), value: payload.node.image, kind: "image" });
+    if (payload.node.video !== void 0) out.push({ path: at("video"), value: payload.node.video, kind: "video" });
+  }
+  const designRefs = (design, base) => {
+    const slideImage = design.slideImage;
+    if (slideImage && (typeof slideImage === "string" || typeof slideImage.src === "string"))
+      out.push({ path: `${base}/slideImage`, value: slideImage, kind: "slide-image" });
+    const logo = design.logo;
+    if (typeof logo === "string" || logo && typeof logo.src === "string") out.push({ path: `${base}/logo`, value: logo, kind: "logo" });
+    else if (logo && typeof logo === "object") {
+      for (const variant of LOGO_VARIANTS)
+        if (logo[variant] !== void 0) out.push({ path: `${base}/logo/${variant}`, value: logo[variant], kind: "logo" });
+    }
+    for (const kind of ["header", "footer"])
+      for (const zone of ["left", "center", "right"]) {
+        const item = rec(rec(design[kind])[zone]);
+        if (item.image !== void 0) out.push({ path: `${base}/${kind}/${zone}/image`, value: item.image, kind: "furniture" });
+      }
+  };
+  designRefs(rec(slide.design), `${slidePath}/design`);
+  if (includeDeck) {
+    designRefs(rec(document.design), "/design");
+    const organizations = Array.isArray(document.organization) ? document.organization : document.organization ? [document.organization] : [];
+    organizations.forEach((organization, index) => {
+      if (organization?.logo !== void 0)
+        out.push({
+          path: Array.isArray(document.organization) ? `/organization/${index}/logo` : "/organization/logo",
+          value: organization.logo,
+          kind: "organization"
+        });
+    });
+    const speakers = Array.isArray(document.speaker) ? document.speaker : document.speaker ? [document.speaker] : [];
+    speakers.forEach((speaker, index) => {
+      if (speaker?.photo !== void 0)
+        out.push({ path: Array.isArray(document.speaker) ? `/speaker/${index}/photo` : "/speaker/photo", value: speaker.photo, kind: "speaker" });
+    });
+  }
+  return out;
+}
+
+// src/audit-rules-a11y.ts
+var PX_TO_PT = 0.75;
+var isLarge = (sizePx, bold) => {
+  const pt = sizePx * PX_TO_PT;
+  return pt >= 18 || bold && pt >= 14;
+};
+function slideBackdrop(context, box) {
+  const { design, composition } = context;
+  const image = composition?.slideImage;
+  if (image?.position === "background") {
+    const overlay = image.overlay && image.overlay.box.width >= composition.width * 0.99 && image.overlay.box.height >= composition.height * 0.99 ? { color: resolveTextColor(image.overlay.color, design, "#000000") ?? "#000000", opacity: image.overlay.opacity } : void 0;
+    return backdropColors({ kind: "image", opacity: image.opacity ?? 1, base: design.backdrop.kind === "solid" ? design.backdrop.color : "#FFFFFF" }, box, design.dimensions, { overlay });
+  }
+  return backdropColors(design.backdrop, box, design.dimensions);
+}
+function inkBox(item, measurement) {
+  const fit = item.text;
+  if (!fit || !Array.isArray(fit.lines) || !fit.lines.length || !item.textStyle || item.quoteLayout || item.metricLayout || item.timelineLayout) return item.box;
+  try {
+    const measure = textWidthMeasurer(item.textStyle, measurement);
+    const width = Math.min(item.box.width, Math.max(...fit.lines.map((line) => measure(line, fit.fontSize))));
+    const height = Math.min(item.box.height, fit.lines.length * fit.lineHeight);
+    const x = item.alignment === "center" ? item.box.x + (item.box.width - width) / 2 : item.alignment === "right" ? item.box.x + item.box.width - width : item.box.x;
+    return { x, y: item.box.y, width, height };
+  } catch {
+    return item.box;
+  }
+}
+function collectSamples(context) {
+  const measurement = context.measurement;
+  const { design, composition } = context;
+  if (!composition) return [];
+  const samples = [];
+  const surface = { colors: [design.colors.surface], unknown: false };
+  const scale = Math.min(design.dimensions.width, design.dimensions.height) / 720;
+  for (const item of composition.items) {
+    if (["chart", "image", "video", "code"].includes(item.field) || item.type === "chart" || item.type === "image" || item.type === "video" || item.type === "code") continue;
+    const backdrop = item.frameBox ? surface : slideBackdrop(context, inkBox(item, measurement));
+    const itemPath = pointerOfDotted(item.path);
+    const heading = item.field === "title" || item.field === "subtitle" || item.field === "tag";
+    const baseSize = (item.text?.fontSize ?? 25 * scale) / scale;
+    const bold = item.field === "title";
+    const label = item.field === "title" ? "Title" : item.field === "subtitle" ? "Subtitle" : item.field === "tag" ? "Tag" : "Text";
+    if (item.field === "table") {
+      const grid = tableGrid(item.value, item.path);
+      for (const row of grid.rows)
+        for (const cell of row) {
+          const fillRef = resolveTextColor(cell.style.fill, design, "");
+          const fill = fillRef || (cell.header ? design.colors.primary : design.colors.surface);
+          const cellBackdrop = { colors: [fill], unknown: false };
+          const cellPath = pointerOfDotted(cell.valuePath);
+          const stylePath = pointerOfDotted(cell.path) + "/style/color";
+          if (cell.style.color != null) {
+            const color = resolveTextColor(cell.style.color, design, design.colors.text);
+            if (color) samples.push({ path: stylePath, color, sizePx: 15, bold: cell.header, backdrop: cellBackdrop, source: "override", colorPath: stylePath, label: "Table cell text" });
+          }
+          if (Array.isArray(cell.value))
+            cell.value.forEach((run, index) => {
+              const colorRef = rec(run).color;
+              if (typeof colorRef !== "string") return;
+              const color = resolveTextColor(colorRef, design, design.colors.text);
+              if (color) samples.push({ path: `${cellPath}/${index}/color`, color, sizePx: rec(run).fontSize ? Number(rec(run).fontSize) / PX_TO_PT : 15, bold: Boolean(rec(run).bold) || cell.header, backdrop: cellBackdrop, source: "override", colorPath: `${cellPath}/${index}/color`, label: "Table cell text" });
+            });
+        }
+      continue;
+    }
+    const parts = [];
+    const layoutOf = item.quoteLayout ?? item.metricLayout ?? item.timelineLayout;
+    if (layoutOf)
+      for (const part of layoutOf.parts) {
+        if (!part.fit || part.visible === false) continue;
+        const role = String(part.role ?? "");
+        parts.push({
+          path: typeof part.path === "string" && part.path.startsWith("slides.") ? pointerOfDotted(part.path) : itemPath,
+          sizePx: part.fit.fontSize / scale,
+          color: role === "footer" ? design.colors.mutedText : role === "value" && item.metricLayout ? design.colors.primary : design.colors.text,
+          label: item.field === "quote" ? role === "footer" ? "Quote attribution" : "Quote" : item.field === "metric" ? role === "value" ? "Metric value" : "Metric label" : "Timeline text"
+        });
+      }
+    else parts.push({ path: itemPath, sizePx: baseSize, color: design.colors.text, label: heading || item.field === "text" ? label : item.field === "items" || item.field === "bullets" ? "List text" : label });
+    for (const part of parts) samples.push({ path: part.path, color: part.color, sizePx: part.sizePx, bold, backdrop, source: "default", label: part.label });
+    const owners = textValues({ [item.field]: item.value }, "");
+    for (const owner of owners) {
+      if (typeof owner.value === "string") continue;
+      const relative = splitPointer(owner.path).slice(1);
+      const base = pointer(...splitPointer(itemPath), ...relative);
+      for (const run of runsOf({ ...owner, path: base })) {
+        if (typeof run.style.color !== "string") continue;
+        const color = resolveTextColor(run.style.color, design, design.colors.text);
+        if (!color) continue;
+        const size = typeof run.style.fontSize === "number" ? run.style.fontSize / PX_TO_PT : baseSize;
+        samples.push({ path: `${run.path}/color`, color, sizePx: size, bold: Boolean(run.style.bold) || bold, backdrop, source: "override", colorPath: `${run.path}/color`, label: "Coloured text" });
+      }
+    }
+  }
+  for (const part of composition.furniture?.parts ?? [])
+    if (part.type === "text")
+      samples.push({ path: pointerOfDotted(part.sourcePath ?? part.path), color: design.colors.mutedText, sizePx: (part.fit?.fontSize ?? 13 * scale) / scale, bold: false, backdrop: slideBackdrop(context, part.box), source: "default", label: part.kind === "header" ? "Header text" : "Footer text" });
+  return samples;
+}
+var contrastRule = rule(
+  "text-contrast",
+  "accessibility",
+  "warning",
+  "Text colour has too little contrast against the background it sits on.",
+  "Low-contrast text is hard or impossible to read for people with low vision, colour-vision differences, glare on a projector or a poor display. WCAG sets 4.5:1 for normal text and 3:1 for large text.",
+  {
+    standard: "WCAG 2.2 SC 1.4.3 Contrast (Minimum), level AA",
+    thresholds: ["contrastNormal", "contrastLarge"],
+    approximations: "Computed on sRGB colours with the WCAG relative-luminance formula, against the background the preview draws: a solid or theme colour, the card surface, a table cell fill, every colour a gradient takes under the text box (sampled on a 5x5 grid, angle respected), or both colours of a pattern. Anti-aliasing, text shadows and font weight are not modelled. Text colour is the preview's (the scheme's dark1 or light1 chosen from the background luminance, where a gradient background counts as light), so a default can fail on a dark gradient."
+  }
+);
+var onImageRule = rule(
+  "text-on-image",
+  "accessibility",
+  "info",
+  "Text sits on a background picture whose pixels cannot be measured.",
+  "Contrast over a photograph depends on the photograph. Without a full-frame overlay that guarantees readability for every possible image, the result cannot be certified from the document.",
+  {
+    standard: "WCAG 2.2 SC 1.4.3 Contrast (Minimum), level AA",
+    thresholds: ["contrastNormal", "contrastLarge"],
+    approximations: "Core never reads picture pixels. The picture is bounded by a grey ramp from black to white, composited through the image opacity and a full-frame design.slideImage.overlay; the text passes only when every step of that ramp passes. An edge-banded overlay is not counted."
+  }
+);
+var contrastRules = [
+  {
+    info: contrastRule,
+    also: [onImageRule],
+    run(context) {
+      const { thresholds } = context;
+      for (const slide of context.slides) {
+        const aggregated = /* @__PURE__ */ new Map();
+        const imageReported = { done: false };
+        for (const sample of collectSamples(slide)) {
+          const large = isLarge(sample.sizePx, sample.bold), needed = large ? thresholds.contrastLarge : thresholds.contrastNormal;
+          const worst = worstContrast(sample.color, sample.backdrop);
+          if (worst.ratio >= needed) continue;
+          if (sample.backdrop.unknown) {
+            if (!imageReported.done) {
+              imageReported.done = true;
+              context.report(onImageRule, {
+                path: sample.path,
+                slide,
+                message: `${sample.label} sits on a background picture. Contrast cannot be guaranteed from the document (against the lightest or darkest possible pixels it is as low as ${worst.ratio.toFixed(1)}:1; ${needed}:1 is needed at this size).`,
+                help: "Add a full-frame overlay to design.slideImage (overlay colour and an opacity high enough that text passes on any picture), use a solid or gradient background behind text, or place text on a card.",
+                measured: { ratio: round(worst.ratio), needed, textColor: sample.color }
+              });
+            }
+            continue;
+          }
+          const key = `${sample.source === "default" ? "default" : sample.path}|${sample.color}|${worst.against}|${large}`;
+          const known = aggregated.get(key);
+          if (known && sample.source === "default") {
+            known.extra++;
+            continue;
+          }
+          const fixes = [];
+          if (sample.colorPath) {
+            const preferred = readableColor([slide.design.colors.text], sample.backdrop, needed);
+            if (preferred !== void 0) {
+              const value = preferred.toUpperCase() === slide.design.colors.text.toUpperCase() ? "text" : preferred;
+              fixes.push({ id: "use-readable-color", label: value === "text" ? "Use the slide text colour" : `Use ${preferred}`, kind: "patch", safe: true, patch: [{ op: "replace", path: sample.colorPath, value }] });
+            }
+          }
+          const diagnostic = context.report(contrastRule, {
+            path: sample.path,
+            slide,
+            message: `${sample.label} colour ${sample.color} on ${worst.against} has a contrast ratio of ${worst.ratio.toFixed(2)}:1; ${needed}:1 is needed for ${large ? "large" : "normal"} text.`,
+            help: sample.source === "override" ? "Pick a colour with enough contrast against the background, or remove this colour override so the theme chooses a readable text colour." : "The theme text colour is unreadable on this background. Change the slide or deck background, the colour scheme (dark1/light1), or give the text an explicit readable colour.",
+            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 });
+        }
+        for (const { diagnostic, extra } of aggregated.values())
+          if (extra) {
+            diagnostic.message += ` ${extra} more text element${extra === 1 ? "" : "s"} on this slide ${extra === 1 ? "has" : "have"} the same problem.`;
+            if (diagnostic.measured) diagnostic.measured.alsoAffected = extra;
+          }
+      }
+    }
+  }
+];
+var round = (value) => Math.round(value * 100) / 100;
+var altRule = rule(
+  "missing-alt-text",
+  "accessibility",
+  "warning",
+  "A picture has no alt text and is not marked decorative.",
+  'People using a screen reader get nothing for a picture without alternative text. A picture that is purely decorative should say so with an empty alt (alt: ""), which is an explicit, reviewed choice instead of an omission.',
+  {
+    standard: "WCAG 2.2 SC 1.1.1 Non-text Content, level A",
+    approximations: "Checks the alt field of images, video, the slide image, logos (design.logo and each LogoSet variant, organization.logo), header/footer images and speaker photos, following asset: references to the assets registry. Whether the text describes the picture well is not judged here (see audit/poor-alt-text). Charts have no alt field in OPF; see audit/chart-text-alternative. Background images and watermarks are decorative by definition and are not checked."
+  }
+);
+var poorAltRule = rule(
+  "poor-alt-text",
+  "accessibility",
+  "info",
+  "Alt text is a file name, a URL, a generic word or very long.",
+  'Alt text such as "image", "IMG_2041.png" or a 400-character paragraph does not do the job of describing a picture: it is read out and adds noise without information.',
+  { standard: "WCAG 2.2 SC 1.1.1 Non-text Content, level A", approximations: 'Pattern checks only: file extensions and camera-style names, a bare generic word, a URL, a leading "image of", and more than 250 characters. It cannot tell whether a plausible sentence is accurate.' }
+);
+var GENERIC_ALT = /^(image|picture|photo|photograph|graphic|img|icon|figure|screenshot|untitled|alt|alt text|logo)$/i;
+var FILE_ALT = /(\.(png|jpe?g|gif|svg|webp|bmp|tiff?|heic|avif)$)|^(img|dsc|image|screenshot|screen shot|photo|pic)[ _-]?\d+/i;
+var kindLabel = (kind) => ({ image: "Image", video: "Video", "slide-image": "Slide image", logo: "Logo", furniture: "Header/footer image", speaker: "Speaker photo", organization: "Organization logo" })[kind] ?? "Picture";
+function altFixes(path, value) {
+  const decorative = typeof value === "string" ? { id: "mark-decorative", label: "Mark as decorative (empty alt)", kind: "patch", safe: false, patch: [{ op: "replace", path, value: { src: value, alt: "" } }] } : { id: "mark-decorative", label: "Mark as decorative (empty alt)", kind: "patch", safe: false, patch: [{ op: "add", path: `${path}/alt`, value: "" }] };
+  return [{ id: "focus-alt", label: "Write alt text", kind: "focus", safe: true, focus: { path, field: "alt", value } }, decorative];
+}
+var altRules = [
+  {
+    info: altRule,
+    run(context) {
+      const seen = /* @__PURE__ */ new Set();
+      context.slides.forEach((slide, index) => {
+        for (const ref of assetRefs(context.document, slide.slide, slide.path, index === 0)) {
+          if (seen.has(ref.path)) continue;
+          seen.add(ref.path);
+          let alt = altOf(ref.value, context.document.assets);
+          if (ref.kind === "video" && !alt) alt = typeof rec(ref.value).title === "string" ? rec(ref.value).title : void 0;
+          if (alt !== void 0 && alt.trim() !== "") continue;
+          if (alt === "") continue;
+          const hasText = alt !== void 0;
+          const organization = ref.kind === "organization" || ref.kind === "logo" ? rec(Array.isArray(context.document.organization) ? context.document.organization[0] : context.document.organization).name : void 0;
+          context.report(altRule, {
+            path: ref.path,
+            slide: ref.path.startsWith("/slides/") ? slide : void 0,
+            message: `${kindLabel(ref.kind)} has ${hasText ? "blank" : "no"} alt text.`,
+            help: `Describe what the ${ref.kind === "logo" || ref.kind === "organization" ? "logo shows" : "picture shows or why it is here"}${typeof organization === "string" ? ` (for a logo, the organization name, ${organization}, is usually right)` : ""}, or set alt to "" if it is purely decorative.`,
+            fixes: altFixes(ref.path, ref.value)
+          });
+        }
+      });
+    }
+  },
+  {
+    info: poorAltRule,
+    run(context) {
+      const seen = /* @__PURE__ */ new Set();
+      context.slides.forEach((slide, index) => {
+        for (const ref of assetRefs(context.document, slide.slide, slide.path, index === 0)) {
+          if (seen.has(ref.path)) continue;
+          seen.add(ref.path);
+          const alt = altOf(ref.value, context.document.assets)?.trim();
+          if (!alt) continue;
+          const source = sourceOfAsset(ref.value);
+          const problem = GENERIC_ALT.test(alt) ? "is a generic word" : FILE_ALT.test(alt) ? "looks like a file name" : /^(https?:\/\/|data:|www\.)/i.test(alt) || source && alt === source ? "is a URL" : /^(image|picture|photo|graphic) of\b/i.test(alt) ? 'starts with "image of", which a screen reader already announces' : alt.length > 250 ? `is ${alt.length} characters long; aim for a sentence or two` : void 0;
+          if (!problem) continue;
+          context.report(poorAltRule, {
+            path: `${ref.path}${typeof ref.value === "object" ? "/alt" : ""}`,
+            slide: ref.path.startsWith("/slides/") ? slide : void 0,
+            message: `${kindLabel(ref.kind)} alt text ${JSON.stringify(alt.length > 60 ? `${alt.slice(0, 57)}...` : alt)} ${problem}.`,
+            help: 'Write what a person who cannot see the picture needs to know, in plain words and without a leading "image of".',
+            fixes: [{ id: "focus-alt", label: "Edit alt text", kind: "focus", safe: true, focus: { path: ref.path, field: "alt", value: ref.value } }]
+          });
+        }
+      });
+    }
+  }
+];
+var missingTitleRule = rule(
+  "missing-slide-title",
+  "accessibility",
+  "warning",
+  "A slide has no title.",
+  "Slide titles are how people using a screen reader, an outline view or keyboard navigation find and tell slides apart; PowerPoint's own accessibility checker reports a missing title too.",
+  { standard: 'WCAG 2.2 SC 2.4.2 Page Titled and SC 2.4.6 Headings and Labels, level AA (PowerPoint: "Missing slide title")', approximations: "Only the slide-level title field counts. Text that merely looks like a heading inside a block does not." }
+);
+var duplicateTitleRule = rule(
+  "duplicate-slide-title",
+  "accessibility",
+  "info",
+  "Two slides have the same title.",
+  "Identical titles make slides indistinguishable in an outline or a screen reader's slide list.",
+  { approximations: 'Titles are compared case-insensitively with whitespace collapsed. Slides that continue one another are not exempt; give a continuation a distinct title such as "(continued)".' }
+);
+var titleRules = [
+  {
+    info: missingTitleRule,
+    run(context) {
+      for (const slide of context.slides) {
+        const title = slide.slide.title;
+        if (typeof title === "string" && title.trim() !== "") continue;
+        context.report(missingTitleRule, {
+          path: slide.path,
+          slide,
+          message: `Slide ${slide.index + 1} has no title.`,
+          help: "Give the slide a short, specific title. If the design has no room for a visible title, keep it short; the title also names the slide for assistive technology.",
+          fixes: [{ id: "focus-title", label: "Write a title", kind: "focus", safe: true, focus: { path: `${slide.path}/title`, field: "title" } }]
+        });
+      }
+    }
+  },
+  {
+    info: duplicateTitleRule,
+    run(context) {
+      const first = /* @__PURE__ */ new Map();
+      for (const slide of context.slides) {
+        const title = typeof slide.slide.title === "string" ? slide.slide.title.trim().replace(/\s+/g, " ").toLowerCase() : "";
+        if (!title) continue;
+        const earlier = first.get(title);
+        if (earlier === void 0) first.set(title, slide.index);
+        else
+          context.report(duplicateTitleRule, {
+            path: `${slide.path}/title`,
+            slide,
+            message: `Slide ${slide.index + 1} has the same title as slide ${earlier + 1}: ${JSON.stringify(String(slide.slide.title).trim())}.`,
+            help: "Make the titles distinct so each slide can be told apart in an outline or by assistive technology.",
+            fixes: [{ id: "focus-title", label: "Edit the title", kind: "focus", safe: true, focus: { path: `${slide.path}/title`, field: "title" } }]
+          });
+      }
+    }
+  }
+];
+var readingOrderRule = rule(
+  "reading-order",
+  "accessibility",
+  "warning",
+  "The order content is read differs from the order it appears on the slide.",
+  "Screen readers, keyboard focus and PowerPoint's selection pane follow the composed order. When it differs from the visual order (top to bottom, then start to end of the reading direction), the slide is read out of sequence.",
+  {
+    standard: 'WCAG 2.2 SC 1.3.2 Meaningful Sequence, level A (PowerPoint: "Check reading order")',
+    approximations: "Compares the composed content order with a visual order recomputed from the composed boxes: items whose vertical centres fall in the same row are ordered along the reading direction (a right-to-left deck is checked by rows only), rows from top to bottom. Headings are expected first. Free-form overlap is not analysed."
+  }
+);
+var readingOrderRules = [
+  {
+    info: readingOrderRule,
+    run(context) {
+      for (const slide of context.slides) {
+        const composition = slide.composition;
+        if (!composition) continue;
+        const body = composition.items.filter((item) => !["title", "subtitle", "tag"].includes(item.field));
+        const title = composition.items.find((item) => item.field === "title");
+        if (title && body.some((item) => item.box.y + item.box.height <= title.box.y + 1)) {
+          const above = body.find((item) => item.box.y + item.box.height <= title.box.y + 1);
+          context.report(readingOrderRule, {
+            path: pointerOfDotted(above.path),
+            slide,
+            message: `Content ${JSON.stringify(shortField(above.path))} is drawn above the title but is read after it.`,
+            help: "Move the title above the content or change the layout so the title is the first thing on the slide."
+          });
+        }
+        if (body.length < 2) continue;
+        const visual = visualOrder(body, slide.rtl);
+        const composed = body.map((item) => item.path);
+        const index = composed.findIndex((path, i) => path !== visual[i]);
+        if (index < 0) continue;
+        const name = (path) => shortField(path);
+        context.report(readingOrderRule, {
+          path: pointerOfDotted(composed[index]),
+          slide,
+          message: `Reading order differs from visual order: ${JSON.stringify(name(composed[index]))} is read at ${ordinal(index)} but appears at ${ordinal(visual.indexOf(composed[index]))}. Composed order: ${composed.map(name).join(", ")}; visual order: ${visual.map(name).join(", ")}.`,
+          help: "Reorder the blocks (or rename promoted regions) so the composed order follows the visual order, or use blocks with an explicit composition instead of region keys.",
+          measured: { firstMismatch: index, composed: composed.length }
+        });
+      }
+    }
+  }
+];
+function visualOrder(items, rtl) {
+  if (rtl) return readingRows(items).flatMap((row) => row.map((item) => item.path));
+  return visualReadingOrder(items).map((item) => item.path);
+}
+var shortField = (path) => path.replace(/^slides\.\d+\./, "");
+var ordinal = (index) => `position ${index + 1}`;
+var linkRule = rule(
+  "link-text",
+  "accessibility",
+  "warning",
+  "Link text does not say where the link goes.",
+  `People who scan links out of context (a screen reader's links list, a link tab order) hear only the text. "click here", "read more" or a long raw URL tells them nothing about the destination.`,
+  { standard: 'WCAG 2.2 SC 2.4.4 Link Purpose (In Context), level A; PowerPoint: "Hyperlink text is not meaningful"', approximations: "Matches a short list of generic phrases in English (after lower-casing and removing punctuation), blank link text, and raw URLs longer than 40 characters. Adjacent runs sharing one link are read as one link." }
+);
+var GENERIC_LINKS = /* @__PURE__ */ new Set(["click here", "click", "here", "link", "this link", "this", "read more", "more", "learn more", "see more", "more info", "more information", "details", "download", "url", "website", "web site", "page", "this page", "visit", "go"]);
+var linkRules = [
+  {
+    info: linkRule,
+    run(context) {
+      for (const slide of context.slides)
+        for (const tv of slide.texts) {
+          if (typeof tv.value === "string") continue;
+          const runs = runsOf(tv);
+          for (let i = 0; i < runs.length; i++) {
+            const run = runs[i];
+            const link = run.style.link;
+            if (typeof link !== "string") continue;
+            let text = run.text;
+            let last = i;
+            while (runs[last + 1] && runs[last + 1].style.link === link) text += runs[++last].text;
+            const normalized = text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, "").replace(/\s+/g, " ").trim();
+            const problem = !text.trim() ? "is blank" : GENERIC_LINKS.has(normalized) ? "is generic" : /^(https?:\/\/|www\.)\S{30,}$/i.test(text.trim()) ? "is a long raw URL" : void 0;
+            i = last;
+            if (!problem) continue;
+            context.report(linkRule, {
+              path: run.path,
+              slide,
+              message: `Link text ${JSON.stringify(text.trim().slice(0, 50))} ${problem}; the destination is ${link.length > 60 ? `${link.slice(0, 57)}...` : link}.`,
+              help: 'Use text that names the destination or action, for example "Q3 financial results (PDF)", instead of "click here".',
+              fixes: [{ id: "focus-link", label: "Edit the text", kind: "focus", safe: true, focus: { path: run.valuePath, field: "link", value: link } }]
+            });
+          }
+        }
+    }
+  }
+];
+var chartColorRule = rule(
+  "chart-color-only",
+  "accessibility",
+  "info",
+  "Chart series may be indistinguishable without colour vision.",
+  "OPF charts have no data labels or patterns, so series are told apart by colour alone (and legend order). Colours that look alike to someone with colour-vision deficiency, or when printed in greyscale, make series impossible to tell apart.",
+  {
+    standard: "WCAG 2.2 SC 1.4.1 Use of Color, level A",
+    thresholds: ["minSeriesColorDifference"],
+    approximations: "Uses the engine's series palette (AuditOptions.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."
+  }
+);
+var chartAltRule = rule(
+  "chart-text-alternative",
+  "accessibility",
+  "info",
+  "A chart is the only content on its slide besides the title.",
+  "A chart conveys a message; people who cannot see it need the message and ideally the numbers in text. OPF has no alt field for charts, so a sentence or table next to the chart is the text alternative.",
+  { standard: "WCAG 2.2 SC 1.1.1 Non-text Content, level A", approximations: "A chart 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 that text states the chart's point." }
+);
+var chartSkip = /(histogram|box|pareto|waterfall|world|united-|canada|australia|map|sparkline|dot-plot|bullet|progress|dumbbell)/;
+var perCategory = /(pie|doughnut|treemap|funnel)/;
+var chartRules = [
+  {
+    info: chartColorRule,
+    run(context) {
+      for (const slide of context.slides)
+        for (const payload of slidePayloads(slide.slide, slide.path)) {
+          const chart = rec(payload.node.chart);
+          const data = rec(chart.data);
+          if (!Array.isArray(data.columns) || !Array.isArray(data.rows)) continue;
+          const type = String(chart.type ?? "").toLowerCase();
+          if (chartSkip.test(type)) continue;
+          const slices = perCategory.test(type);
+          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);
+          if (!palette.length) continue;
+          const used = Array.from({ length: Math.min(count, 24) }, (_, i) => palette[i % palette.length]);
+          const pairs = [];
+          for (let a = 0; a < used.length; a++)
+            for (let b = a + 1; b < used.length; b++) {
+              let worst = { model: "normal vision", difference: colorDifference(used[a], used[b]) };
+              for (const model of visionModels) {
+                const difference = colorDifference(simulateVision(used[a], model), simulateVision(used[b], model));
+                if (difference < worst.difference) worst = { model, difference };
+              }
+              if (worst.difference < context.thresholds.minSeriesColorDifference) pairs.push({ a, b, ...worst });
+            }
+          const cycles = count > palette.length;
+          if (!pairs.length && !cycles) continue;
+          pairs.sort((x, y) => x.difference - y.difference);
+          const names = slices ? data.rows.map((row) => String(row?.[0] ?? "")) : data.columns.slice(1).map(String);
+          const describe = (p) => `${JSON.stringify(names[p.a] ?? `#${p.a + 1}`)} and ${JSON.stringify(names[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` : ""}.`,
+            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: chartAltRule,
+    run(context) {
+      for (const slide of context.slides) {
+        const payloads = slidePayloads(slide.slide, slide.path).filter((p) => !p.node.blocks && !p.node.composition || p.root);
+        const charts = payloads.filter((p) => p.node.chart !== void 0);
+        if (!charts.length) continue;
+        const textual = (p) => ["text", "items", "bullets", "table", "quote", "metric", "timeline"].some((field) => p.node[field] !== void 0 && p.node[field] !== "" && !(Array.isArray(p.node[field]) && p.node[field].length === 0));
+        if (payloads.some(textual) || typeof slide.slide.subtitle === "string" && slide.slide.subtitle.trim()) continue;
+        const chart = charts[0];
+        context.report(chartAltRule, {
+          path: `${chart.path}/chart`,
+          slide,
+          message: `The chart on slide ${slide.index + 1} has no text beside it that states what it shows.`,
+          help: "Add a subtitle or text block with the chart's takeaway (and key numbers), or a table with the data, so the message does not depend on seeing the chart.",
+          fixes: [{ id: "focus-subtitle", label: "Write a subtitle", kind: "focus", safe: true, focus: { path: `${slide.path}/subtitle`, field: "text" } }]
+        });
+      }
+    }
+  }
+];
+var languageRule = rule(
+  "missing-language",
+  "accessibility",
+  "info",
+  "The presentation does not declare its language.",
+  "Screen readers and text-to-speech choose pronunciation and hyphenation from the declared language; spell checkers and translation tools use it too.",
+  { standard: "WCAG 2.2 SC 3.1.1 Language of Page, level A", approximations: "Only the presentation-level `language` is checked, not the language of individual runs (OPF has no per-run language)." }
+);
+var languageRules = [
+  {
+    info: languageRule,
+    run(context) {
+      if (context.document.language !== void 0) return;
+      context.report(languageRule, {
+        path: "",
+        message: "The presentation has no language set.",
+        help: 'Set `language` to a language id from the languages catalog or a BCP 47 tag, for example "en-US".',
+        fixes: [{ id: "focus-language", label: "Set the language", kind: "focus", safe: true, focus: { path: "/language", field: "language" } }]
+      });
+    }
+  }
+];
+var accessibilityRules = [
+  ...contrastRules,
+  ...altRules,
+  ...titleRules,
+  ...readingOrderRules,
+  ...linkRules,
+  ...chartRules,
+  ...languageRules
+];
+
+// src/audit-rules-design.ts
+var PX_TO_PT2 = 0.75;
+var round2 = (value, places = 1) => Math.round(value * 10 ** places) / 10 ** places;
+var overflowRule = rule(
+  "text-overflow",
+  "design",
+  "warning",
+  "Text or a table does not fit its space at the smallest allowed size.",
+  "Core composition shrinks text to the readable minimum and then reports what still does not fit. Overflowing text is clipped or runs over other content in the preview and in PowerPoint.",
+  {
+    approximations: `Uses composeSlide at the deck's slide size with the fonts of the resolved font scheme. Without a host-supplied text measurement (AuditOptions.textMeasurement) widths are core's portable estimate, which can differ from the real font by a few percent; pass the renderer's measurement for font-exact results. Content in a composition that sets overflow: "error" is reported as an error, as the author asked.`
+  }
+);
+var smallCellRule = rule(
+  "small-cell",
+  "design",
+  "info",
+  "A content cell is too small for comfortable reading.",
+  "Cells narrower than about 100 px or shorter than 60 px (at 720 px slide height) leave no room for readable content.",
+  { approximations: "The composeSlide threshold, in reference pixels scaled to the slide size." }
+);
+var unresolvedRule = rule(
+  "unresolved-content",
+  "design",
+  "warning",
+  "Content cannot be drawn as authored.",
+  "composeSlide reports content it cannot place or an effect it does not support (for example a picture bullet without a logo, a date field without a date, or an unsupported image treatment). The preview and the export fall back."
+);
+var layoutFailedRule = rule(
+  "layout-failed",
+  "design",
+  "warning",
+  "The slide layout could not be computed.",
+  "Composition threw for a slide that passed schema validation, so geometry-based rules (contrast, overflow, reading order, resolution) were skipped for it."
+);
+var minFontRule = rule(
+  "min-font-size",
+  "design",
+  "warning",
+  "Text is drawn smaller than the readable minimum.",
+  "Small type is unreadable from the back of a room and on a phone. The engine's own default floor is 12 pt (16 px); anything much below that was lowered on purpose or by a composition that could not fit the text.",
+  {
+    standard: "Common presentation guidance (12 pt minimum for body text; 18 pt or more is easier to read from a distance).",
+    thresholds: ["minFontSizePt"],
+    approximations: "Sizes are those composeSlide fitted, expressed on the 13.33 x 7.5 in reference slide (96 px per inch, so 1 px is 0.75 pt; a smaller canvas scales type down with it) and explicit run fontSize values in points. Per payload, the smallest part (a metric label or a quote attribution) is reported. Table cell text (default 11.25 pt), code and header/footer furniture are not checked."
+  }
+);
+var layoutRules = [
+  {
+    info: overflowRule,
+    also: [smallCellRule, unresolvedRule, layoutFailedRule, minFontRule],
+    run(context) {
+      const deckLevel = /* @__PURE__ */ new Set();
+      for (const slide of context.slides) {
+        if (slide.layoutError)
+          context.report(layoutFailedRule, { path: slide.path, slide, message: `Layout failed: ${slide.layoutError}`, help: "Fix the composition settings or content structure named in the message; geometry-based audit rules were skipped for this slide." });
+        for (const { diagnostic, strict } 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);
+          }
+          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.", severity: strict ? "error" : void 0 });
+          else if (diagnostic.code === "small-cell")
+            context.report(smallCellRule, { path, slide, message: diagnostic.message, help: "Use fewer blocks on the slide or a layout with larger cells." });
+          else context.report(unresolvedRule, { path, slide: path.startsWith("/slides/") ? slide : void 0, message: diagnostic.message, help: "Supply what the message asks for, or remove the setting that cannot be honoured." });
+        }
+        for (const tv of slide.texts)
+          for (const run of runsOf(tv))
+            if (typeof run.style.fontSize === "number" && run.style.fontSize < context.thresholds.minFontSizePt)
+              context.report(minFontRule, {
+                path: `${run.path}/fontSize`,
+                slide,
+                message: `Text run is set to ${run.style.fontSize} pt, below the ${context.thresholds.minFontSizePt} pt minimum.`,
+                help: "Remove the size override so the text uses the fitted size, or raise it.",
+                measured: { sizePt: run.style.fontSize, minimumPt: context.thresholds.minFontSizePt },
+                fixes: [{ id: "focus-font-size", label: "Edit the size", kind: "focus", safe: true, focus: { path: `${run.path}/fontSize`, field: "fontSize" } }]
+              });
+        const composition = slide.composition;
+        if (!composition) continue;
+        const scale = Math.min(composition.width, composition.height) / 720;
+        const limitPx = context.thresholds.minFontSizePt / PX_TO_PT2;
+        const small = (path, sizes, label) => {
+          const known = sizes.filter((size) => size !== void 0);
+          const sizePx = known.length ? Math.min(...known) / scale : void 0;
+          if (sizePx === void 0 || sizePx >= limitPx - 1e-6) return;
+          context.report(minFontRule, {
+            path,
+            slide,
+            message: `${label} is drawn at ${round2(sizePx * PX_TO_PT2)} pt${scale === 1 ? "" : " (reference slide size)"}, below the ${context.thresholds.minFontSizePt} pt minimum.`,
+            help: "Shorten the text or give it more room so it can be drawn larger; check composition.minFontSize and run fontSize settings that force small type.",
+            measured: { sizePt: round2(sizePx * PX_TO_PT2, 2), minimumPt: context.thresholds.minFontSizePt }
+          });
+        };
+        for (const item of composition.items) {
+          if (item.field === "code" || item.field === "table" || item.type === "code" || item.type === "table") continue;
+          const layout = item.quoteLayout ?? item.metricLayout ?? item.timelineLayout;
+          if (layout) small(pointerOfDotted(item.path), layout.parts.map((part) => part.visible === false ? void 0 : part.fit?.fontSize), "The smallest text");
+          else small(pointerOfDotted(item.path), [item.text?.fontSize], item.field === "title" ? "Title" : "Text");
+        }
+      }
+    }
+  }
+];
+var outsideRule = rule(
+  "font-outside-scheme",
+  "design",
+  "warning",
+  "Text uses a font family that is not in the deck's font scheme.",
+  "The font scheme is the deck's font choice. A run that names another family will not follow a font-scheme change, may be missing on the viewer's machine, and breaks the deck's typographic consistency.",
+  { approximations: "Compares the run's fontFamily (case-insensitively) with the heading, body, code and accent families of the slide's resolved font scheme and the scheme's major/minor fonts. Families that the host substitutes are still different names here." }
+);
+var countRule = rule(
+  "font-family-count",
+  "design",
+  "info",
+  "The deck uses more font families than the recommended maximum.",
+  "More than two or three families (heading, body, plus code where used) makes a deck look unplanned and increases the font bytes a viewer needs.",
+  { thresholds: ["maxFontFamilies"], approximations: "Counts the distinct heading and body families of every slide's resolved scheme, the code family on slides with code, the accent family on slides with a tag, and every run fontFamily." }
+);
+var fontRules = [
+  {
+    info: outsideRule,
+    run(context) {
+      for (const slide of context.slides) {
+        const allowed = new Set(
+          [slide.design.fonts.heading, slide.design.fonts.body, slide.design.fonts.code, slide.design.fonts.accent, slide.design.fontScheme.major, slide.design.fontScheme.minor].filter((family) => typeof family === "string").map((family) => family.toLowerCase())
+        );
+        const reported = /* @__PURE__ */ new Set();
+        for (const tv of slide.texts)
+          for (const run of runsOf(tv)) {
+            const family = run.style.fontFamily;
+            if (typeof family !== "string" || !family.trim() || allowed.has(family.trim().toLowerCase()) || reported.has(family.toLowerCase())) continue;
+            reported.add(family.toLowerCase());
+            context.report(outsideRule, {
+              path: `${run.path}/fontFamily`,
+              slide,
+              message: `Text uses ${JSON.stringify(family)}, which is not in the font scheme (${[.../* @__PURE__ */ new Set([slide.design.fonts.heading, slide.design.fonts.body])].join(" / ")}).`,
+              help: "Remove the fontFamily override to use the scheme font, or change the deck's font scheme so the family is part of it.",
+              fixes: [{ id: "remove-font-family", label: "Use the scheme font", kind: "patch", safe: false, patch: [{ op: "remove", path: `${run.path}/fontFamily` }] }]
+            });
+          }
+      }
+    }
+  },
+  {
+    info: countRule,
+    run(context) {
+      const families = /* @__PURE__ */ new Map();
+      const add = (family) => {
+        if (typeof family === "string" && family.trim()) families.set(family.trim().toLowerCase(), family.trim());
+      };
+      for (const slide of context.slides) {
+        add(slide.design.fonts.heading);
+        add(slide.design.fonts.body);
+        if (slide.payloads.some((p) => p.node.code !== void 0)) add(slide.design.fonts.code);
+        if (typeof slide.slide.tag === "string") add(slide.design.fonts.accent);
+        for (const tv of slide.texts) for (const run of runsOf(tv)) add(run.style.fontFamily);
+      }
+      if (families.size <= context.thresholds.maxFontFamilies) return;
+      context.report(countRule, {
+        path: "/design",
+        message: `The deck uses ${families.size} font families (${[...families.values()].join(", ")}); the recommended maximum is ${context.thresholds.maxFontFamilies}.`,
+        help: "Use one heading and one body family, add a code family only where code appears, and remove run-level fontFamily overrides.",
+        measured: { families: families.size, maximum: context.thresholds.maxFontFamilies }
+      });
+    }
+  }
+];
+var titlePositionRule = rule(
+  "title-position",
+  "design",
+  "info",
+  "Titles of slides with the same layout sit in different places.",
+  "A title that jumps between slides of one layout looks like a mistake when the deck is clicked through. Slides of one layout should hold their titles still.",
+  {
+    thresholds: ["titlePositionTolerance"],
+    approximations: "Compares the composed title box origin of slides that share a layout id, a header presence and a slide-image position; covers (no body content) are skipped because their heading group is centred on purpose. The reference is the most common position, ties going to the earliest slide."
+  }
+);
+var titleRules2 = [
+  {
+    info: titlePositionRule,
+    run(context) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const slide of context.slides) {
+        const composition = slide.composition;
+        const title = composition?.items.find((item) => item.field === "title");
+        if (!composition || !title) continue;
+        if (!composition.items.some((item) => !["title", "subtitle", "tag"].includes(item.field))) continue;
+        const key = [slide.layout?.id ?? (typeof slide.slide.layout === "string" ? slide.slide.layout : "(inferred)"), (composition.furniture?.headerBottom ?? 0) > 0, composition.slideImage?.position ?? "-"].join("|");
+        const list = groups.get(key) ?? [];
+        list.push({ slide, x: title.box.x / composition.width, y: title.box.y / composition.height });
+        groups.set(key, list);
+      }
+      const tolerance = context.thresholds.titlePositionTolerance;
+      for (const [key, members] of groups) {
+        if (members.length < 2) continue;
+        const counts = [];
+        for (const member of members) {
+          const near = counts.find((c) => Math.abs(c.x - member.x) <= tolerance && Math.abs(c.y - member.y) <= tolerance);
+          if (near) near.n++;
+          else counts.push({ x: member.x, y: member.y, n: 1 });
+        }
+        const reference = counts.reduce((best, c) => c.n > best.n ? c : best);
+        for (const member of members)
+          if (Math.abs(member.x - reference.x) > tolerance || Math.abs(member.y - reference.y) > tolerance)
+            context.report(titlePositionRule, {
+              path: `${member.slide.path}/title`,
+              slide: member.slide,
+              message: `The title is ${round2(Math.abs(member.x - reference.x) * 100)}% (across) and ${round2(Math.abs(member.y - reference.y) * 100)}% (down) away from where other "${key.split("|")[0]}" slides place it.`,
+              help: "Slides of one layout should hold the title in the same place: check the header, the slide image, the layout and composition overrides on this slide.",
+              measured: { offsetX: round2(member.x - reference.x, 3), offsetY: round2(member.y - reference.y, 3) }
+            });
+      }
+    }
+  }
+];
+var wordRule = rule(
+  "slide-word-count",
+  "design",
+  "info",
+  "A slide holds a lot of text.",
+  "Slides that carry a page of prose are read instead of presented, and are hard to scan on a screen reader or a phone. Split them or move detail to notes.",
+  { thresholds: ["maxWordsPerSlide"], approximations: "Counts word-like segments (Unicode word boundaries, so Chinese and Japanese count by word) in the title, subtitle, tag, text, lists, tables, quotes, metrics and timelines. Code and speaker notes are excluded." }
+);
+var wordRules = [
+  {
+    info: wordRule,
+    run(context) {
+      for (const slide of context.slides) {
+        const words = slide.texts.reduce((sum, tv) => sum + countWords(plainText(tv.value)), 0);
+        if (words <= context.thresholds.maxWordsPerSlide) continue;
+        context.report(wordRule, {
+          path: slide.path,
+          slide,
+          message: `Slide ${slide.index + 1} has ${words} words; more than ${context.thresholds.maxWordsPerSlide} is hard to read as a slide.`,
+          help: "Cut it to the points that matter, split it over several slides, or move the detail into speaker notes or a handout.",
+          measured: { words, maximum: context.thresholds.maxWordsPerSlide }
+        });
+      }
+    }
+  }
+];
+var resolutionRule = rule(
+  "image-resolution",
+  "design",
+  "warning",
+  "An image has too few pixels for the size it is shown at.",
+  "An image stretched beyond its pixel size looks blurry or blocky on a projector or a high-density screen.",
+  {
+    thresholds: ["minImagePpi"],
+    approximations: "Only embedded data: images (and asset: references to them) have readable pixel sizes; URLs and files are never fetched, so they are not checked. The displayed size is the composed box (cropped images are measured as the cover scale, fitted ones as the contain scale). Effective ppi is the image pixels per inch of the 96 px/inch reference slide. SVG is vector and exempt."
+  }
+);
+var resolutionRules = [
+  {
+    info: resolutionRule,
+    run(context) {
+      const assets = context.document.assets;
+      const seen = /* @__PURE__ */ new Set();
+      const check = (path, value, box, cover, slide) => {
+        if (seen.has(path)) return;
+        seen.add(path);
+        const size = intrinsicImageSize(value, assets);
+        if (!size || size.svg || box.width <= 0 || box.height <= 0) return;
+        const scale = cover ? Math.max(box.width / size.width, box.height / size.height) : Math.min(box.width / size.width, box.height / size.height);
+        const ppi = 96 / scale;
+        if (ppi >= context.thresholds.minImagePpi) return;
+        context.report(resolutionRule, {
+          path,
+          slide,
+          message: `The ${size.width}x${size.height} px image is shown ${round2(box.width / 96)} x ${round2(box.height / 96)} in, about ${round2(ppi, 0)} pixels per inch; ${context.thresholds.minImagePpi} are needed to look sharp.`,
+          help: "Use a larger source image, or show it smaller. Re-exporting a small image at a higher size does not add detail.",
+          measured: { widthPx: size.width, heightPx: size.height, ppi: round2(ppi, 0), minimumPpi: context.thresholds.minImagePpi }
+        });
+      };
+      for (const slide of context.slides) {
+        const composition = slide.composition;
+        const fill = rec(slide.slide.design).imageFill ?? rec(context.document.design).imageFill;
+        if (composition) {
+          for (const item of composition.items) if (item.field === "image") check(pointerOfDotted(item.path), item.value, item.box, fill === "crop", slide);
+          if (composition.slideImage) check(pointerOfDotted(composition.slideImage.sourcePath), composition.slideImage.value, composition.slideImage.box, composition.slideImage.fill === "crop", slide);
+        }
+        const background = slide.design.backgroundImage;
+        if (background && background.fit !== "tile") check(background.path, rec({ src: background.source }), slide.design.dimensions, background.fit === "cover", background.path.startsWith("/slides/") ? slide : void 0);
+      }
+    }
+  }
+];
+var placeholderRule = rule(
+  "placeholder-text",
+  "content",
+  "warning",
+  "Placeholder text was left in the deck.",
+  '"Lorem ipsum", "Click to add title", "TBD" and bracketed prompts are scaffolding. Shipping them reads as unfinished work.',
+  { approximations: 'Case-insensitive patterns for lorem ipsum, template prompts ("Click to add...", "Your title here", "[Insert ...]", a bare "Title" or "Text"), and the markers TBD, TBC, TODO, FIXME and XXX in capitals. A deliberate use of the words is flagged too; disable the rule for that slide with ignorePaths.' }
+);
+var emptyTextRule = rule(
+  "empty-text",
+  "content",
+  "info",
+  "A text field is present but empty.",
+  "An empty title, text block or list item draws nothing, and leaves a hole in the outline and for assistive technology."
+);
+var emptySlideRule = rule(
+  "empty-slide",
+  "content",
+  "warning",
+  "A slide has no content at all.",
+  "A slide with no title, no content and no picture is almost always an accident of editing. (A deliberately blank slide can use the blank layout.)"
+);
+var PLACEHOLDERS = [
+  { pattern: /lorem ipsum|dolor sit amet|consectetur adipiscing/i, label: "lorem ipsum" },
+  { pattern: /\b(click|tap) to (add|edit|enter)\b|\b(add|enter|insert|type) (a |your |the )?(title|subtitle|text|heading|caption|content|name|description)( here)?\s*$/i, label: "a template prompt" },
+  { pattern: /\b(your|the) (title|subtitle|name|company|text|logo|content) (goes )?here\b|\b(title|subtitle|text|heading|content|description) (goes )?here\b/i, label: "a template prompt" },
+  { pattern: /\[(insert|add|your|enter|name|title|date|company|tbd|tbc|todo|placeholder)[^\]]{0,40}\]/i, label: "a bracketed prompt" },
+  { pattern: /\b(TBD|TBC|TODO|FIXME)\b|\bXXX+\b|\?\?\?/, label: "a TBD/TODO marker" },
+  { pattern: /^\s*(title|subtitle|heading|text|slide title|new slide|untitled( slide| presentation)?|presentation title|sample text|placeholder)\s*$/i, label: "a template default" }
+];
+var VARIABLE_TOKEN = /\\\{\{|\{\{\s*([a-z][a-z0-9-]*)\s*(?:\|[^{}]*)?\}\}/g;
+var contentRules = [
+  {
+    info: placeholderRule,
+    run(context) {
+      for (const slide of context.slides)
+        for (const tv of slide.texts) {
+          const text = plainText(tv.value);
+          const hit = PLACEHOLDERS.find(({ pattern }) => pattern.test(text));
+          if (!hit) continue;
+          context.report(placeholderRule, {
+            path: tv.path,
+            slide,
+            message: `Text looks like ${hit.label}: ${JSON.stringify(text.length > 60 ? `${text.slice(0, 57)}...` : text)}.`,
+            help: "Replace it with the real content, or delete the element.",
+            fixes: [{ id: "focus-text", label: "Edit the text", kind: "focus", safe: true, focus: { path: tv.path, field: "text" } }]
+          });
+        }
+    }
+  },
+  {
+    info: emptyTextRule,
+    run(context) {
+      for (const slide of context.slides)
+        for (const tv of slide.texts) {
+          if (["table", "table-header", "list-description"].includes(tv.role)) continue;
+          if (plainText(tv.value).trim() !== "") continue;
+          context.report(emptyTextRule, {
+            path: tv.path,
+            slide,
+            message: `The ${tv.role === "list" ? "list item" : tv.role === "body" ? "text" : tv.role} is empty.`,
+            help: "Write the text, or remove the field so the slide does not carry an empty element.",
+            fixes: [{ id: "focus-text", label: "Edit the text", kind: "focus", safe: true, focus: { path: tv.path, field: "text" } }]
+          });
+        }
+    }
+  },
+  {
+    info: emptySlideRule,
+    run(context) {
+      for (const slide of context.slides) {
+        if (slide.slide.layout === "blank") continue;
+        const has = (value) => value !== void 0 && value !== null && !(typeof value === "string" && value.trim() === "") && !(Array.isArray(value) && value.length === 0);
+        const hasText = slide.texts.some((tv) => plainText(tv.value).trim() !== "");
+        const hasObject = slidePayloads(slide.slide, slide.path).some((p) => ["image", "video", "chart", "table", "code", "metric", "quote", "timeline"].some((field) => has(p.node[field])));
+        const hasSlideImage = has(rec(slide.slide.design).slideImage);
+        if (hasText || hasObject || hasSlideImage) continue;
+        context.report(emptySlideRule, { path: slide.path, slide, message: `Slide ${slide.index + 1} has no title and no content.`, help: "Add content, delete the slide, or give it the blank layout if it is intentionally empty." });
+      }
+    }
+  }
+];
+var variableRule = rule(
+  "unfilled-variable",
+  "content",
+  "warning",
+  "A template variable was never filled in.",
+  "`{{name}}` tokens, `var:` colour references to undeclared variables and declared variables without a value are template scaffolding. In a finished deck they show up literally, or fall back to a default colour.",
+  {
+    approximations: "Feature-detected from the document alone: `{{id}}` / `{{id|format}}` tokens (the RR-32 template syntax; `\\{{` escapes) in any string outside `variables`, `extensions` and `catalogs`; `var:<id>` references with no declaration in `variables`; and declared non-colour variables with no value that are not `required: false`. A template (`template: true`) reports its tokens as findings too: ignore the rule for a template on purpose, or fill it first. Core's `resolveVariables` (RR-32) is the authority once it is released; this check needs no import of it."
+  }
+);
+var variableRules = [
+  {
+    info: variableRule,
+    run(context) {
+      const doc = context.document;
+      const declared = rec(doc.variables);
+      const found = [];
+      const walk = (value, path, depth) => {
+        if (depth > 64) return;
+        if (typeof value === "string") {
+          if (value.startsWith("data:")) return;
+          const reference = /^var:([a-z][a-z0-9-]*)$/.exec(value);
+          if (reference && !(reference[1] in declared)) found.push({ path: pointer(...path), message: `Colour reference ${JSON.stringify(value)} names a variable that is not declared in variables.` });
+          for (const match of value.matchAll(VARIABLE_TOKEN))
+            if (match[1]) found.push({ path: pointer(...path), message: `Template variable ${JSON.stringify(match[0])} is still in the text.` });
+          return;
+        }
+        if (Array.isArray(value)) {
+          value.forEach((entry, index) => {
+            walk(entry, [...path, String(index)], depth + 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);
+          }
+      };
+      walk(doc, [], 0);
+      for (const [id, entry] of Object.entries(declared)) {
+        const declaration = rec(entry);
+        if (typeof entry === "object" && entry !== null && declaration.type !== void 0 && declaration.type !== "color" && declaration.value === void 0 && declaration.required !== false)
+          found.push({ path: pointer("variables", id), message: `Variable ${JSON.stringify(id)} (${String(declaration.type)}) has no value.` });
+      }
+      const slides = context.slides;
+      for (const finding of found) {
+        const parts = splitPointer(finding.path);
+        const slide = parts[0] === "slides" ? slides[Number(parts[1])] : void 0;
+        context.report(variableRule, {
+          path: finding.path,
+          slide,
+          message: finding.message,
+          help: doc.template === true ? "This document is a template: fill it with its values (opf fill, or resolveVariables) before auditing, or ignore this rule for templates." : "Fill the variable (or declare it), or replace the token with the real value."
+        });
+      }
+    }
+  }
+];
+var designRules = [
+  ...layoutRules,
+  ...fontRules,
+  ...titleRules2,
+  ...wordRules,
+  ...resolutionRules,
+  ...contentRules,
+  ...variableRules
+];
+
+// src/audit.ts
+var DEFAULT_AUDIT_THRESHOLDS = Object.freeze({
+  contrastNormal: 4.5,
+  contrastLarge: 3,
+  minFontSizePt: 11,
+  maxWordsPerSlide: 120,
+  maxFontFamilies: 3,
+  minImagePpi: 96,
+  titlePositionTolerance: 0.01,
+  minSeriesColorDifference: 10
+});
+var rules = [...accessibilityRules, ...designRules];
+var infos = rules.flatMap((entry) => [entry.info, ...entry.also ?? []]);
+var auditRules = Object.freeze(infos.map((info) => Object.freeze({ ...info })));
+var DOCS = "https://github.com/OpenPresentation/opf/blob/main/docs/audit.md";
+var severities = ["error", "warning", "info"];
+function findAuditRule(name) {
+  return auditRules.find((info) => info.id === name || info.name === name);
+}
+function ruleFor(name, what) {
+  const found = findAuditRule(name);
+  if (!found) throw new TypeError(`Unknown audit rule ${JSON.stringify(name)} in ${what}. Known rules: ${auditRules.map((info) => info.id).join(", ")}.`);
+  return found;
+}
+function resolveOptions(options) {
+  const object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  if (!object(options)) throw new TypeError("Audit options must be an object.");
+  const allowed = ["rules", "ignore", "only", "ignorePaths", "thresholds", "catalogs", "textMeasurement", "chartPalette"];
+  for (const key of Object.keys(options)) if (!allowed.includes(key)) throw new TypeError(`Unknown audit option ${JSON.stringify(key)}. Options: ${allowed.join(", ")}.`);
+  const severity = /* @__PURE__ */ new Map();
+  if (options.rules !== void 0) {
+    if (!object(options.rules)) throw new TypeError('Audit rules must map rule ids to a severity or "off".');
+    for (const [name, value] of Object.entries(options.rules)) {
+      if (typeof value !== "string" || value !== "off" && !severities.includes(value)) throw new TypeError(`Audit rule ${JSON.stringify(name)}: severity must be error, warning, info or off.`);
+      severity.set(ruleFor(name, "rules").id, value);
+    }
+  }
+  const list = (value, what) => {
+    if (value === void 0) return void 0;
+    if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) throw new TypeError(`Audit ${what} must be an array of rule ids.`);
+    return new Set(value.map((name) => ruleFor(name, what).id));
+  };
+  const ignore = list(options.ignore, "ignore"), only = list(options.only, "only");
+  const ignorePaths = [];
+  if (options.ignorePaths !== void 0) {
+    if (!Array.isArray(options.ignorePaths)) throw new TypeError("Audit ignorePaths must be an array of {rule, path}.");
+    for (const entry of options.ignorePaths) {
+      if (!object(entry) || typeof entry.rule !== "string" || typeof entry.path !== "string" || entry.path !== "" && !entry.path.startsWith("/"))
+        throw new TypeError('Each audit ignorePaths entry needs a rule id (or "*") and a JSON Pointer path.');
+      ignorePaths.push({ rule: entry.rule === "*" ? "*" : ruleFor(entry.rule, "ignorePaths").id, path: splitPointer(entry.path) });
+    }
+  }
+  const thresholds = { ...DEFAULT_AUDIT_THRESHOLDS };
+  if (options.thresholds !== void 0) {
+    if (!object(options.thresholds)) throw new TypeError("Audit thresholds must be an object.");
+    for (const [key, value] of Object.entries(options.thresholds)) {
+      if (!(key in DEFAULT_AUDIT_THRESHOLDS)) throw new TypeError(`Unknown audit threshold ${JSON.stringify(key)}. Thresholds: ${Object.keys(DEFAULT_AUDIT_THRESHOLDS).join(", ")}.`);
+      if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new TypeError(`Audit threshold ${key} must be a positive number.`);
+      thresholds[key] = value;
+    }
+  }
+  if (options.chartPalette !== void 0 && (!Array.isArray(options.chartPalette) || !options.chartPalette.every((color) => typeof color === "string" && /^#[0-9a-fA-F]{6}$/.test(color))))
+    throw new TypeError("Audit chartPalette must be an array of #RRGGBB colours.");
+  return {
+    enabled: (info) => severity.get(info.id) !== "off" && !ignore?.has(info.id) && (!only || only.has(info.id)),
+    severity: (info) => {
+      const value = severity.get(info.id);
+      return value === "off" ? void 0 : value;
+    },
+    ignorePaths,
+    thresholds
+  };
+}
+var measurementFor = (options, index) => typeof options.textMeasurement === "function" ? options.textMeasurement(index) : options.textMeasurement;
+var slideCompositionOptions = (document, slide, index, count, design, layout, options) => {
+  const merged = { ...rec(document.design), ...rec(slide.design) };
+  return {
+    ...design.dimensions,
+    layout,
+    presentation: document,
+    slideIndex: index,
+    slideNumber: index + 1,
+    slideCount: count,
+    fonts: design.fonts,
+    contentAlignment: merged.contentAlignment,
+    titleAlignment: merged.titleAlignment,
+    contentBox: merged.contentBox,
+    textMeasurement: measurementFor(options, index),
+    socialPlatforms: catalogs.socialPlatforms,
+    // Core never consults a clock; a fixed date only lets `date: true` furniture be measured.
+    date: "2000-01-01"
+  };
+};
+function relax(value) {
+  const copy = JSON.parse(JSON.stringify(value));
+  const walk = (node) => {
+    if (Array.isArray(node)) return node.forEach(walk);
+    if (node && typeof node === "object") {
+      const object = node;
+      if (object.overflow === "error") object.overflow = "warn";
+      for (const child of Object.values(object)) walk(child);
+    }
+  };
+  walk(copy);
+  return copy;
+}
+function buildSlides(document, options) {
+  const lookup = createLookup(document, options.catalogs);
+  const slides = Array.isArray(document.slides) ? document.slides : [];
+  return slides.map((slide, index) => {
+    const design = resolveDesign(document, slide, index, lookup);
+    const layout = typeof slide.layout === "string" ? lookup("layouts", slide.layout) : void 0;
+    const path = pointer("slides", index);
+    const context = {
+      index,
+      slide,
+      path,
+      ...typeof slide.id === "string" ? { id: slide.id } : {},
+      design,
+      ...layout ? { layout } : {},
+      layoutDiagnostics: [],
+      measurement: measurementFor(options, index),
+      payloads: slidePayloads(slide, path),
+      texts: textValues(slide, path),
+      rtl: false
+    };
+    try {
+      context.rtl = resolveScriptFonts(document, { slideIndex: index }).rtl === true;
+    } catch {
+    }
+    const compose = (input, withLayout) => composeSlide(input, slideCompositionOptions(document, input, index, slides.length, design, withLayout, options));
+    let composition;
+    try {
+      composition = compose(slide, layout);
+      context.layoutDiagnostics.push(...composition.diagnostics.map((diagnostic) => ({ diagnostic, strict: false })));
+    } catch (error) {
+      if (error instanceof OPFCompositionError) {
+        context.layoutDiagnostics.push(...error.diagnostics.map((diagnostic) => ({ diagnostic, strict: true })));
+        try {
+          composition = compose(relax(slide), layout ? relax(layout) : void 0);
+        } catch (second) {
+          context.layoutError = second instanceof Error ? second.message : String(second);
+        }
+      } else context.layoutError = error instanceof Error ? error.message : String(error);
+    }
+    if (composition) context.composition = composition;
+    return context;
+  });
+}
+function locator(source) {
+  const tree = parseTree(source.startsWith("\uFEFF") ? ` ${source.slice(1)}` : source, [], { disallowComments: true, allowTrailingComma: false });
+  const lineStarts = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\r") {
+      if (source[i + 1] === "\n") i++;
+      lineStarts.push(i + 1);
+    } else if (source[i] === "\n") lineStarts.push(i + 1);
+  }
+  const at = (offset, length) => {
+    let lo = 0, hi = lineStarts.length;
+    while (lo + 1 < hi) {
+      const mid = lo + hi >> 1;
+      if ((lineStarts[mid] ?? 0) <= offset) lo = mid;
+      else hi = mid;
+    }
+    return { offset, length, line: lo + 1, column: offset - (lineStarts[lo] ?? 0) + 1 };
+  };
+  return (path) => {
+    let node = tree;
+    const found = [];
+    for (const part of splitPointer(path)) {
+      const next = node?.type === "array" ? node.children?.[Number(part)] : node?.type === "object" ? node.children?.find((property) => property.children?.[0]?.value === part)?.children?.[1] : void 0;
+      if (!next) break;
+      node = next;
+      found.push(next);
+    }
+    const target = found.length === splitPointer(path).length ? node : found[found.length - 1] ?? tree;
+    return target ? at(target.offset, target.length) : void 0;
+  };
+}
+function emptyReport(options, thresholds) {
+  return {
+    valid: true,
+    documentValid: true,
+    diagnostics: [],
+    counts: { error: 0, warning: 0, info: 0 },
+    rulesRun: [],
+    slideCount: 0,
+    thresholds,
+    checks: { textMeasurement: options.textMeasurement !== void 0 ? "provided" : "estimated", backgroundPixels: "not-read", imageBytes: "embedded-only", nativeExport: "not-checked" }
+  };
+}
+function auditObject(document, options, locate) {
+  const resolved = resolveOptions(options);
+  const report = emptyReport(options, resolved.thresholds);
+  const { diagnostics, counts } = report;
+  const validation = validatePresentation(document);
+  if (!validation.valid) {
+    report.documentValid = false;
+    for (const issue of validation.errors.slice(0, 50))
+      diagnostics.push({
+        ruleId: "audit/invalid-document",
+        severity: "error",
+        category: "content",
+        scope: "document",
+        path: issue.path === "/" ? "" : issue.path,
+        message: `The document does not pass schema validation, so it was not audited: ${issue.message}`,
+        help: "Fix the document first (see `opf lint`), then audit again.",
+        ...locate ? { location: locate(issue.path === "/" ? "" : issue.path) } : {}
+      });
+    for (const diagnostic of diagnostics) counts[diagnostic.severity]++;
+    report.valid = counts.error === 0;
+    return report;
+  }
+  const doc = document;
+  const slides = buildSlides(doc, options);
+  const order = new Map(infos.map((info, index) => [info.id, index]));
+  const context = {
+    document: doc,
+    slides,
+    thresholds: resolved.thresholds,
+    options,
+    lookup: createLookup(doc, options.catalogs),
+    chartPalette: options.chartPalette ?? DEFAULT_CHART_PALETTE,
+    report(info, finding) {
+      const severity = resolved.severity(info) ?? finding.severity ?? info.severity;
+      const diagnostic = {
+        ruleId: info.id,
+        severity,
+        category: info.category,
+        scope: "document",
+        path: finding.path,
+        message: finding.message,
+        help: finding.help,
+        definition: `${DOCS}#${info.id.replace("/", "")}`,
+        ...finding.slide ? { slide: finding.slide.index, ...finding.slide.id ? { slideId: finding.slide.id } : {} } : {},
+        ...finding.measured ? { measured: finding.measured } : {},
+        ...finding.fixes?.length ? { fixes: finding.fixes } : {},
+        ...finding.suggestions ? { suggestions: finding.suggestions } : {}
+      };
+      if (!resolved.enabled(info)) return diagnostic;
+      const parts = splitPointer(finding.path);
+      const ignored = resolved.ignorePaths.some((entry) => (entry.rule === "*" || entry.rule === info.id) && entry.path.every((part, index) => parts[index] === part));
+      if (!ignored) diagnostics.push(diagnostic);
+      return diagnostic;
+    }
+  };
+  const rulesRun = [];
+  for (const entry of rules) {
+    const all = [entry.info, ...entry.also ?? []];
+    if (!all.some((info) => resolved.enabled(info))) continue;
+    rulesRun.push(...all.filter((info) => resolved.enabled(info)).map((info) => info.id));
+    entry.run(context);
+  }
+  diagnostics.sort((a, b) => (a.slide ?? -1) - (b.slide ?? -1) || (order.get(a.ruleId) ?? 0) - (order.get(b.ruleId) ?? 0) || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+  if (locate) for (const diagnostic of diagnostics) {
+    const location = locate(diagnostic.path);
+    if (location) diagnostic.location = location;
+  }
+  for (const diagnostic of diagnostics) counts[diagnostic.severity]++;
+  report.valid = counts.error === 0;
+  report.rulesRun = rulesRun;
+  report.slideCount = slides.length;
+  return report;
+}
+function auditPresentation(document, options = {}) {
+  return auditObject(document, options);
+}
+function auditSource(source, options = {}) {
+  const syntax = lintSource(source);
+  if (syntax.schemaValid === null) {
+    const report = emptyReport(options, resolveOptions(options).thresholds);
+    report.documentValid = false;
+    for (const diagnostic of syntax.diagnostics)
+      report.diagnostics.push({
+        ruleId: "audit/invalid-document",
+        severity: "error",
+        category: "content",
+        scope: "document",
+        path: diagnostic.path,
+        message: `The source is not valid JSON, so it was not audited: ${diagnostic.message}`,
+        help: diagnostic.help,
+        ...diagnostic.location ? { location: diagnostic.location } : {}
+      });
+    report.counts = { error: report.diagnostics.length, warning: 0, info: 0 };
+    report.valid = false;
+    return report;
+  }
+  return auditObject(JSON.parse(source.replace(/^/, "")), options, locator(source));
+}
+
+export { DEFAULT_AUDIT_THRESHOLDS, DEFAULT_CHART_PALETTE, auditPresentation, auditRules, auditSource, findAuditRule };