@multiplatform.one/theme 7.83.0 → 7.83.2

package/dist/esm/audit/themeMatrix.native.js

@@ -0,0 +1,1515 @@
+import { aaTextContrastRatio, measureContrast, minContrastRatio } from "../theme/colorRules.native.js";
+function _instanceof(left, right) {
+  "@swc/helpers - instanceof";
+
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
+function captureMatrixSnapshot() {
+  var _ref, _ref1, _ref2, _document_querySelector;
+  if (typeof document === "undefined") throw new Error("captureMatrixSnapshot needs a DOM");
+  var SKIP_TAGS = /* @__PURE__ */new Set(["script", "style", "link", "meta", "head", "title", "noscript", "br", "wbr", "template"]);
+  var round = function round2(n) {
+    return Math.round(n * 4) / 4;
+  };
+  var toRect = function toRect2(r) {
+    return {
+      x: round(r.x),
+      y: round(r.y),
+      w: round(r.width),
+      h: round(r.height)
+    };
+  };
+  function parseCssColor(raw) {
+    var s = raw.trim().toLowerCase();
+    if (s === "transparent") return [0, 0, 0, 0];
+    var m = s.match(/^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)(?:[\s,/]+([\d.%]+))?\s*\)$/);
+    if (!m) return null;
+    var a = 1;
+    if (m[4] !== void 0) {
+      a = m[4].endsWith("%") ? Number.parseFloat(m[4]) / 100 : Number.parseFloat(m[4]);
+    }
+    return [Number.parseFloat(m[1]), Number.parseFloat(m[2]), Number.parseFloat(m[3]), a];
+  }
+  function toHex(rgb) {
+    var h = function h2(v) {
+      return Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
+    };
+    return `#${h(rgb[0])}${h(rgb[1])}${h(rgb[2])}`;
+  }
+  function blend(top, bottom) {
+    var a = top[3];
+    return [top[0] * a + bottom[0] * (1 - a), top[1] * a + bottom[1] * (1 - a), top[2] * a + bottom[2] * (1 - a)];
+  }
+  function effectiveBackground(el) {
+    var layers = [];
+    var overImage = false;
+    var node = el;
+    var opaqueBase = null;
+    while (node) {
+      var cs = getComputedStyle(node);
+      if (cs.backgroundImage && cs.backgroundImage !== "none") overImage = true;
+      if (node.getAttribute("data-mpo-chart-backdrop") === "patterned") overImage = true;
+      var parsed = parseCssColor(cs.backgroundColor);
+      if (parsed && parsed[3] > 0) {
+        if (parsed[3] >= 0.999) {
+          opaqueBase = [parsed[0], parsed[1], parsed[2]];
+          break;
+        }
+        layers.push(parsed);
+      }
+      node = node.parentElement;
+    }
+    if (!opaqueBase) {
+      return {
+        hex: "#ffffff",
+        resolved: false,
+        overImage
+      };
+    }
+    var acc = opaqueBase;
+    for (var i = layers.length - 1; i >= 0; i--) {
+      acc = blend(layers[i], acc);
+    }
+    return {
+      hex: toHex(acc),
+      resolved: !overImage,
+      overImage
+    };
+  }
+  function effectiveOpacity(el) {
+    var o = 1;
+    var node = el;
+    while (node) {
+      var v = Number.parseFloat(getComputedStyle(node).opacity);
+      if (!Number.isNaN(v)) o *= v;
+      node = node.parentElement;
+    }
+    return o;
+  }
+  var GEOMETRY_PROPS = ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomLeftRadius", "borderBottomRightRadius", "borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft", "rowGap", "columnGap", "fontSize", "fontWeight", "fontFamily", "lineHeight", "letterSpacing"];
+  var root = (_ref = (_ref1 = (_ref2 = (_document_querySelector = document.querySelector("#mpo-matrix-root")) !== null && _document_querySelector !== void 0 ? _document_querySelector : document.querySelector("[data-mpo-matrix-root]")) !== null && _ref2 !== void 0 ? _ref2 : document.querySelector("#storybook-root")) !== null && _ref1 !== void 0 ? _ref1 : document.querySelector("#root")) !== null && _ref !== void 0 ? _ref : document.body;
+  var storyRendered = !!root && root.children.length > 0;
+  var geometry = [];
+  var textSamples = [];
+  var iconSamples = [];
+  var chartSamples = [];
+  var svgRootCount = 0;
+  var capturedSvgRoots = /* @__PURE__ */new Set();
+  function accessibleName(el) {
+    var labelledBy = el.getAttribute("aria-labelledby");
+    if (labelledBy) {
+      var name = labelledBy.split(/\s+/).map(function (id) {
+        var _ref3;
+        var _document_getElementById;
+        return (_ref3 = (_document_getElementById = document.getElementById(id)) === null || _document_getElementById === void 0 ? void 0 : _document_getElementById.textContent) !== null && _ref3 !== void 0 ? _ref3 : "";
+      }).join(" ").trim();
+      if (name) return name.slice(0, 100);
+    }
+    var labels = "labels" in el ? el.labels : null;
+    var labelText = labels ? Array.from(labels).map(function (label) {
+      var _label_textContent;
+      return (_label_textContent = label.textContent) !== null && _label_textContent !== void 0 ? _label_textContent : "";
+    }).join(" ") : "";
+    return (el.getAttribute("aria-label") || labelText || el.getAttribute("title") || el.textContent || "").trim().slice(0, 100);
+  }
+  function controlName(el) {
+    if (el.matches("[data-mp-input-box]")) {
+      var input = el.querySelector("input, textarea, select");
+      if (input) return accessibleName(input) || input.getAttribute("placeholder") || "input";
+    }
+    return accessibleName(el);
+  }
+  function unsupportedCompositing(el) {
+    var backgroundInGroup = false;
+    for (var node = el; node; node = node.parentElement) {
+      var cs = getComputedStyle(node);
+      var background = parseCssColor(cs.backgroundColor);
+      if (background && background[3] > 0) backgroundInGroup = true;
+      if (Number.parseFloat(cs.opacity) < 1 && backgroundInGroup) return true;
+      if (cs.mixBlendMode && cs.mixBlendMode !== "normal") return true;
+    }
+    return false;
+  }
+  function collectIcon(el, key2, cs) {
+    var _ref3;
+    var _el_parentElement, _namedControl_parentElement;
+    if (el.tagName.toLowerCase() !== "svg" || ((_el_parentElement = el.parentElement) === null || _el_parentElement === void 0 ? void 0 : _el_parentElement.closest("svg"))) return;
+    var backdrop = effectiveBackground(el);
+    var rect = el.getBoundingClientRect();
+    var sample = {
+      key: key2,
+      context: accessibleName(el),
+      status: "conveying",
+      background: backdrop.hex,
+      backgroundResolved: backdrop.resolved,
+      overImage: backdrop.overImage,
+      shapeCount: 0,
+      distinctPaints: 0,
+      rect: toRect(rect)
+    };
+    iconSamples.push(sample);
+    if (cs.visibility === "hidden" || cs.visibility === "collapse" || effectiveOpacity(el) === 0 || rect.width === 0 || rect.height === 0) {
+      sample.status = "hidden";
+      return;
+    }
+    if (el.closest('[disabled], [aria-disabled="true"], [data-disabled="true"]')) {
+      sample.status = "disabled-control";
+      return;
+    }
+    var controls = 'button, a[href], label, summary, [data-mp-input-box], [role="button"], [role="link"], [role="menuitem"], [role="tab"], [role="checkbox"], [role="radio"], [role="switch"], [role="option"], [role="combobox"]';
+    var namedControl = el.closest(controls);
+    while (namedControl && !controlName(namedControl)) namedControl = (_ref3 = (_namedControl_parentElement = namedControl.parentElement) === null || _namedControl_parentElement === void 0 ? void 0 : _namedControl_parentElement.closest(controls)) !== null && _ref3 !== void 0 ? _ref3 : null;
+    if (namedControl) sample.context = controlName(namedControl);else if (el.closest('[aria-hidden="true"], [role="presentation"], [role="none"]')) {
+      sample.status = "decorative-standalone";
+      return;
+    }
+    if (!backdrop.resolved) {
+      sample.unmeasurable = "unresolved-backdrop";
+      return;
+    }
+    if (el.querySelector("use")) {
+      sample.unmeasurable = "use-indirection";
+      return;
+    }
+    var paintNodes = [el, ...Array.from(el.querySelectorAll("*"))];
+    for (var ancestor = el.parentElement; ancestor; ancestor = ancestor.parentElement) paintNodes.push(ancestor);
+    if (paintNodes.some(function (node2) {
+      var style2 = getComputedStyle(node2);
+      return style2.filter && style2.filter !== "none" || style2.maskImage && style2.maskImage !== "none";
+    })) {
+      sample.unmeasurable = "masked-or-filtered";
+      return;
+    }
+    var background = [Number.parseInt(backdrop.hex.slice(1, 3), 16), Number.parseInt(backdrop.hex.slice(3, 5), 16), Number.parseInt(backdrop.hex.slice(5, 7), 16)];
+    var paints = /* @__PURE__ */new Set();
+    var kinds = /* @__PURE__ */new Set();
+    var alphaValue = function alphaValue2(raw2) {
+      return raw2.endsWith("%") ? Number.parseFloat(raw2) / 100 : Number.parseFloat(raw2);
+    };
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = Array.from(el.querySelectorAll("path, rect, circle, ellipse, line, polyline, polygon, text, tspan"))[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var shape = _step2.value;
+        if (shape.closest("defs, clipPath, mask, pattern, marker, symbol")) continue;
+        var style = getComputedStyle(shape);
+        var hiddenGroup = false;
+        for (var node = shape; node && node !== el; node = node.parentElement) {
+          if (getComputedStyle(node).display === "none") hiddenGroup = true;
+        }
+        if (hiddenGroup || style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse" || effectiveOpacity(shape) === 0) continue;
+        var bounds = shape.getBBox();
+        if (typeof SVGGeometryElement !== "undefined" && _instanceof(shape, SVGGeometryElement) && shape.getTotalLength() === 0) continue;
+        sample.shapeCount++;
+        if (unsupportedCompositing(shape)) {
+          sample.unmeasurable = "unsupported-compositing";
+          return;
+        }
+        if ([style.markerStart, style.markerMid, style.markerEnd].some(function (value) {
+          return value && value !== "none";
+        })) {
+          sample.unmeasurable = "unsupported-paint";
+          return;
+        }
+        for (var _i = 0, _iter = ["fill", "stroke"]; _i < _iter.length; _i++) {
+          var kind = _iter[_i];
+          if (kind === "fill" && (shape.tagName.toLowerCase() === "line" || bounds.width === 0 || bounds.height === 0)) continue;
+          if (kind === "stroke" && !(Number.parseFloat(style.strokeWidth) > 0)) continue;
+          var raw = style[kind].trim().toLowerCase();
+          if (raw === "none") continue;
+          var ink = parseCssColor(raw === "currentcolor" ? style.color : raw);
+          if (!ink) {
+            sample.unmeasurable = "unsupported-paint";
+            return;
+          }
+          var paintOpacity = alphaValue(kind === "fill" ? style.fillOpacity : style.strokeOpacity);
+          ink[3] *= (Number.isFinite(paintOpacity) ? paintOpacity : 1) * effectiveOpacity(shape);
+          if (ink[3] === 0) continue;
+          paints.add(toHex(blend(ink, background)));
+          kinds.add(kind);
+        }
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+    sample.distinctPaints = paints.size;
+    if (paints.size === 0) sample.unmeasurable = "no-paint";else if (paints.size > 1) sample.unmeasurable = "multicolor";else {
+      sample.paint = Array.from(paints)[0];
+      sample.paintKinds = Array.from(kinds);
+    }
+  }
+  function collectChart(el, key2) {
+    var _el_getAttribute, _el_getAttribute1, _el_getAttribute2, _el_getAttribute3, _sample, _unmeasurable;
+    var backdrop = effectiveBackground(el);
+    var rawCount = el.getAttribute("data-mpo-chart-datum-count");
+    var expected = rawCount !== null && /^\d+$/.test(rawCount) ? Number(rawCount) : -1;
+    var owner = el.closest("[data-mpo-chart-owner]");
+    var rows = owner ? Array.from(owner.querySelectorAll("[data-mpo-chart-datum-text]")).filter(function (row) {
+      return row.tagName.toLowerCase() !== "svg" && row.closest("[data-mpo-chart-owner]") === owner;
+    }) : [];
+    var visible = function visible2(node2) {
+      var style2 = getComputedStyle(node2);
+      var rect2 = node2.getBoundingClientRect();
+      return style2.visibility !== "hidden" && style2.visibility !== "collapse" && effectiveOpacity(node2) > 0 && (rect2.width > 0 || rect2.height > 0);
+    };
+    var completeRows = rows.filter(function (row, index3) {
+      var _name_textContent, _value_textContent;
+      var name = row.querySelector("[data-mpo-chart-datum-label]");
+      var value = row.querySelector("[data-mpo-chart-datum-value]");
+      return row.getAttribute("data-mpo-chart-datum-text") === String(index3) && name && value && visible(name) && visible(value) && !!((_name_textContent = name.textContent) === null || _name_textContent === void 0 ? void 0 : _name_textContent.trim()) && !!((_value_textContent = value.textContent) === null || _value_textContent === void 0 ? void 0 : _value_textContent.trim());
+    });
+    var sample = {
+      key: key2,
+      kind: (_el_getAttribute = el.getAttribute("data-mpo-chart")) !== null && _el_getAttribute !== void 0 ? _el_getAttribute : "",
+      context: accessibleName(el),
+      label: ((_el_getAttribute1 = el.getAttribute("aria-label")) !== null && _el_getAttribute1 !== void 0 ? _el_getAttribute1 : "").trim(),
+      background: backdrop.hex,
+      backgroundResolved: backdrop.resolved,
+      marks: [],
+      labels: [],
+      chrome: [],
+      unaccountedPaint: [],
+      separation: {
+        declared: el.getAttribute("data-mpo-chart-separated") === "true"
+      },
+      datumText: {
+        viewId: (_el_getAttribute2 = el.getAttribute("data-mpo-chart-data-view")) !== null && _el_getAttribute2 !== void 0 ? _el_getAttribute2 : void 0,
+        expectedValues: (_el_getAttribute3 = el.getAttribute("data-mpo-chart-data-expected")) !== null && _el_getAttribute3 !== void 0 ? _el_getAttribute3 : void 0,
+        declared: el.getAttribute("data-mpo-chart-datum-text") === "true",
+        expected,
+        observed: completeRows.length,
+        complete: expected > 0 && rows.length === expected && completeRows.length === expected
+      }
+    };
+    chartSamples.push(sample);
+    if (!visible(el)) sample.unmeasurable = "hidden-chart";else if (!backdrop.resolved) sample.unmeasurable = "unresolved-backdrop";else if (el.querySelector("use")) sample.unmeasurable = "use-indirection";
+    var marks = Array.from(el.querySelectorAll("[data-mpo-chart-mark]"));
+    var certifiedMasks = /* @__PURE__ */new Set();
+    if ((sample.kind === "pie" || sample.kind === "donut") && marks.length > 1) {
+      var round2 = function round3(value) {
+        return Math.round(value * 1e3) / 1e3;
+      };
+      var pathTokens = function pathTokens2(path) {
+        var _path_replace_match;
+        return JSON.stringify(((_path_replace_match = path.replace(/^path\(["']?|["']?\)$/g, "").match(/[a-zA-Z]|[-+]?(?:\d*\.)?\d+(?:[eE][-+]?\d+)?/g)) !== null && _path_replace_match !== void 0 ? _path_replace_match : []).map(function (token) {
+          return Number.isNaN(Number(token)) ? token : Number(token);
+        }));
+      };
+      var point = function point2(radius, angle) {
+        return `${round2(radius * Math.cos(angle - Math.PI / 2))},${round2(radius * Math.sin(angle - Math.PI / 2))}`;
+      };
+      var proofs = marks.map(function (mark2) {
+        var _mark_getAttribute2, _mark_getAttribute1;
+        if (mark2.tagName.toLowerCase() !== "path" || mark2.getAttribute("data-mpo-chart-mask") !== "eroded-arc-v1") return;
+        var values = ((_mark_getAttribute2 = mark2.getAttribute("data-mpo-chart-slice")) !== null && _mark_getAttribute2 !== void 0 ? _mark_getAttribute2 : "").split(",").map(Number);
+        if (values.length !== 4 || !values.every(Number.isFinite)) return;
+        var [start, end, inner, outer] = values;
+        var span = end - start;
+        if (start < 0 || end > Math.PI * 2 + 1e-9 || span <= 0 || span >= Math.PI * 2 || inner < 0 || outer <= inner) return;
+        var radius = (inner + outer) / 2;
+        var projection = Math.min(outer, Math.max(inner, radius * Math.cos(span / 2)));
+        var radialDistance = Math.sqrt(Math.max(0, Math.pow(radius, 2) + Math.pow(projection, 2) - 2 * radius * projection * Math.cos(span / 2)));
+        if (outer - radius <= 1.002 || radius - inner <= 1.002 || radialDistance <= 1.002) return;
+        var large = Number(span >= Math.PI);
+        var d = `M${point(outer, start)}A${round2(outer)},${round2(outer)},0,${large},1,${point(outer, end)}` + (inner ? `L${point(inner, end)}A${round2(inner)},${round2(inner)},0,${large},0,${point(inner, start)}Z` : "L0,0Z");
+        if (mark2.getAttribute("d") !== d) return;
+        var markStyle = getComputedStyle(mark2);
+        var paintedD = markStyle.getPropertyValue("d");
+        if (paintedD && pathTokens(paintedD) !== pathTokens(d)) return;
+        if (markStyle.stroke !== "none") return;
+        var reference = /^url\(["']?#([^"')]+)["']?\)$/.exec((_mark_getAttribute1 = mark2.getAttribute("mask")) !== null && _mark_getAttribute1 !== void 0 ? _mark_getAttribute1 : "");
+        if (!reference) return;
+        var matches = Array.from(document.querySelectorAll("[id]")).filter(function (node3) {
+          return node3.id === reference[1];
+        });
+        var mask = matches[0];
+        if (matches.length !== 1 || mask.tagName.toLowerCase() !== "mask" || !el.contains(mask)) return;
+        var definitions = mask.parentElement;
+        if ((definitions === null || definitions === void 0 ? void 0 : definitions.tagName.toLowerCase()) !== "defs" || definitions.parentElement !== mark2.parentElement) return;
+        var computedReference = /^url\(["']?([^"')]+)["']?\)$/.exec(markStyle.maskImage);
+        if (!computedReference || !["match-source", "luminance"].includes(markStyle.maskMode)) return;
+        try {
+          if (new URL(computedReference[1], document.baseURI).href !== new URL(`#${reference[1]}`, document.URL).href) return;
+        } catch (unused) {
+          return;
+        }
+        if (mask.getAttribute("maskUnits") !== "userSpaceOnUse" || mask.getAttribute("maskContentUnits") !== "userSpaceOnUse" || getComputedStyle(mask).getPropertyValue("mask-type") !== "luminance") return;
+        var bounds2 = {
+          x: -outer - 2,
+          y: -outer - 2,
+          width: (outer + 2) * 2,
+          height: (outer + 2) * 2
+        };
+        if (Object.entries(bounds2).some(function (param) {
+          var [name, value] = param;
+          return Number(mask.getAttribute(name)) !== value;
+        })) return;
+        if (mask.children.length !== 1) return;
+        var boundary = mask.children[0];
+        if (boundary.tagName.toLowerCase() !== "path" || boundary.getAttribute("d") !== d) return;
+        for (var _i = 0, _iter = [definitions, mask, boundary]; _i < _iter.length; _i++) {
+          var node2 = _iter[_i];
+          var style2 = getComputedStyle(node2);
+          if (style2.transform !== "none" || style2.filter !== "none" || style2.maskImage !== "none" || style2.clipPath !== "none" || style2.opacity !== "1" || style2.visibility !== "visible" || style2.display === "none") return;
+          if ([style2.markerStart, style2.markerMid, style2.markerEnd].some(function (value) {
+            return value && value !== "none";
+          })) return;
+        }
+        if (unsupportedCompositing(boundary)) return;
+        var boundaryStyle = getComputedStyle(boundary);
+        if (boundaryStyle.fill !== "rgb(255, 255, 255)" || boundaryStyle.stroke !== "rgb(0, 0, 0)" || boundaryStyle.fillOpacity !== "1" || boundaryStyle.strokeOpacity !== "1" || Number.parseFloat(boundaryStyle.strokeWidth) !== 2 || boundaryStyle.strokeLinejoin !== "round" || boundaryStyle.strokeLinecap !== "round" || boundaryStyle.paintOrder !== "normal" || boundaryStyle.vectorEffect !== "none" || boundaryStyle.strokeDasharray !== "none") return;
+        var boundaryD = boundaryStyle.getPropertyValue("d");
+        if (boundaryD && pathTokens(boundaryD) !== pathTokens(d)) return;
+        for (var node1 = mark2; node1; node1 = node1.parentElement) {
+          var style1 = getComputedStyle(node1);
+          if (style1.transform.startsWith("matrix3d") || style1.perspective && style1.perspective !== "none") return;
+        }
+        var ctm2 = mark2.getScreenCTM();
+        if (!ctm2) return;
+        var matrix = [ctm2.a, ctm2.b, ctm2.c, ctm2.d, ctm2.e, ctm2.f];
+        var firstScale = Math.hypot(ctm2.a + ctm2.d, ctm2.b - ctm2.c);
+        var secondScale = Math.hypot(ctm2.a - ctm2.d, ctm2.b + ctm2.c);
+        var smallest = Math.abs(firstScale - secondScale) / 2;
+        if (!matrix.every(Number.isFinite) || !Number.isFinite(smallest) || smallest <= 0) return;
+        var measuredGap = 2 * smallest * window.devicePixelRatio;
+        var gap = Math.abs(measuredGap - 2) <= 8 * Number.EPSILON ? 2 : measuredGap;
+        return {
+          mark: mark2,
+          start,
+          end,
+          inner,
+          outer,
+          matrix,
+          gap
+        };
+      });
+      var first = proofs[0];
+      if (first && Math.abs(first.start) < 1e-9 && proofs.every(function (proof2, index3) {
+        return proof2 && proof2.inner === first.inner && proof2.outer === first.outer && proof2.matrix.every(function (value, axis) {
+          return value === first.matrix[axis];
+        }) && Math.abs(proof2.start - (index3 ? proofs[index3 - 1].end : 0)) < 1e-9;
+      }) && Math.abs(proofs[proofs.length - 1].end - Math.PI * 2) < 1e-9) {
+        var _iteratorNormalCompletion2 = true,
+          _didIteratorError2 = false,
+          _iteratorError2 = void 0;
+        try {
+          for (var _iterator2 = proofs[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var proof = _step2.value;
+            certifiedMasks.add(proof.mark);
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+        sample.separation.method = "eroded-arc";
+        sample.separation.minimumGapPx = first.gap;
+      }
+    }
+    function paintSample(shape, paintKey, label) {
+      var item2 = {
+        key: paintKey,
+        label,
+        background: backdrop.hex
+      };
+      if (shape.closest("defs, clipPath, mask, pattern, marker, symbol")) return {
+        ...item2,
+        unmeasurable: "no-paint"
+      };
+      if (!visible(shape)) return {
+        ...item2,
+        unmeasurable: "no-paint"
+      };
+      if (!backdrop.resolved) return {
+        ...item2,
+        unmeasurable: "unresolved-backdrop"
+      };
+      for (var node2 = shape; node2; node2 = node2.parentElement) {
+        var style2 = getComputedStyle(node2);
+        if (style2.filter && style2.filter !== "none" || style2.maskImage && style2.maskImage !== "none" && !(node2 === shape && certifiedMasks.has(shape))) return {
+          ...item2,
+          unmeasurable: "masked-or-filtered"
+        };
+        if (style2.clipPath && style2.clipPath !== "none") return {
+          ...item2,
+          unmeasurable: "unsupported-paint"
+        };
+      }
+      if (unsupportedCompositing(shape)) return {
+        ...item2,
+        unmeasurable: "unsupported-compositing"
+      };
+      var style1 = getComputedStyle(shape);
+      if ([style1.markerStart, style1.markerMid, style1.markerEnd].some(function (value) {
+        return value && value !== "none";
+      })) return {
+        ...item2,
+        unmeasurable: "unsupported-paint"
+      };
+      var bounds2;
+      try {
+        bounds2 = shape.getBBox();
+      } catch (unused) {
+        return {
+          ...item2,
+          unmeasurable: "unsupported-paint"
+        };
+      }
+      var background = [Number.parseInt(backdrop.hex.slice(1, 3), 16), Number.parseInt(backdrop.hex.slice(3, 5), 16), Number.parseInt(backdrop.hex.slice(5, 7), 16)];
+      var paints = /* @__PURE__ */new Set();
+      for (var _i = 0, _iter = ["fill", "stroke"]; _i < _iter.length; _i++) {
+        var kind = _iter[_i];
+        if (kind === "fill" && (shape.tagName.toLowerCase() === "line" || bounds2.width === 0 || bounds2.height === 0)) continue;
+        if (kind === "stroke" && !(Number.parseFloat(style1.strokeWidth) > 0)) continue;
+        var raw = style1[kind].trim().toLowerCase();
+        if (raw === "none") continue;
+        var ink = parseCssColor(raw === "currentcolor" ? style1.color : raw);
+        if (!ink) return {
+          ...item2,
+          unmeasurable: "unsupported-paint"
+        };
+        var alphaRaw = kind === "fill" ? style1.fillOpacity : style1.strokeOpacity;
+        var alpha = Number.parseFloat(alphaRaw) / (alphaRaw.endsWith("%") ? 100 : 1);
+        ink[3] *= (Number.isFinite(alpha) ? alpha : 1) * effectiveOpacity(shape);
+        if (ink[3] > 0) paints.add(toHex(blend(ink, background)));
+      }
+      if (paints.size !== 1) return {
+        ...item2,
+        unmeasurable: paints.size ? "multicolor" : "no-paint"
+      };
+      return {
+        ...item2,
+        paint: Array.from(paints)[0]
+      };
+    }
+    var _iteratorNormalCompletion12 = true,
+      _didIteratorError12 = false,
+      _iteratorError12 = void 0;
+    try {
+      for (var _iterator12 = marks.entries()[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+        var [index2, mark] = _step12.value;
+        var _mark_getAttribute;
+        var tag = mark.tagName.toLowerCase();
+        var item = !["path", "rect", "circle", "ellipse", "line", "polyline", "polygon"].includes(tag) ? {
+          key: `${key2}/mark:${index2}`,
+          label: (_mark_getAttribute = mark.getAttribute("data-mpo-chart-mark")) !== null && _mark_getAttribute !== void 0 ? _mark_getAttribute : "",
+          background: backdrop.hex,
+          unmeasurable: "unsupported-paint"
+        } : paintSample(mark, `${key2}/mark:${index2}`, mark.getAttribute("data-mpo-chart-mark") || `mark ${index2 + 1}`);
+        sample.marks.push(item);
+      }
+    } catch (err) {
+      _didIteratorError12 = true;
+      _iteratorError12 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+          _iterator12.return();
+        }
+      } finally {
+        if (_didIteratorError12) {
+          throw _iteratorError12;
+        }
+      }
+    }
+    var _iteratorNormalCompletion22 = true,
+      _didIteratorError22 = false,
+      _iteratorError22 = void 0;
+    try {
+      for (var _iterator22 = Array.from(el.querySelectorAll("text, tspan")).entries()[Symbol.iterator](), _step22; !(_iteratorNormalCompletion22 = (_step22 = _iterator22.next()).done); _iteratorNormalCompletion22 = true) {
+        var [index12, node] = _step22.value;
+        var text = Array.from(node.childNodes).filter(function (child2) {
+          return child2.nodeType === 3;
+        }).map(function (child2) {
+          var _child_textContent;
+          return (_child_textContent = child2.textContent) !== null && _child_textContent !== void 0 ? _child_textContent : "";
+        }).join("").trim();
+        if (text) sample.labels.push(paintSample(node, `${key2}/label:${index12}`, text));
+      }
+    } catch (err) {
+      _didIteratorError22 = true;
+      _iteratorError22 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion22 && _iterator22.return != null) {
+          _iterator22.return();
+        }
+      } finally {
+        if (_didIteratorError22) {
+          throw _iteratorError22;
+        }
+      }
+    }
+    var _iteratorNormalCompletion3 = true,
+      _didIteratorError3 = false,
+      _iteratorError3 = void 0;
+    try {
+      for (var _iterator3 = Array.from(el.querySelectorAll("path, rect, circle, ellipse, line, polyline, polygon, image, foreignObject, use")).entries()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+        var [index22, drawable] = _step3.value;
+        var _drawable_getScreenCTM;
+        if (drawable.hasAttribute("data-mpo-chart-mark")) continue;
+        var tag1 = drawable.tagName.toLowerCase();
+        var item1 = paintSample(drawable, `${key2}/drawable:${index22}`, `unaccounted ${tag1}`);
+        if (item1.unmeasurable === "no-paint") continue;
+        var chrome = drawable.getAttribute("data-mpo-chart-chrome");
+        var style = getComputedStyle(drawable);
+        var rect = drawable.getBoundingClientRect();
+        var ctm = (_drawable_getScreenCTM = drawable.getScreenCTM) === null || _drawable_getScreenCTM === void 0 ? void 0 : _drawable_getScreenCTM.call(drawable);
+        var squareSum = ctm ? Math.pow(ctm.a, 2) + Math.pow(ctm.b, 2) + Math.pow(ctm.c, 2) + Math.pow(ctm.d, 2) : NaN;
+        var determinant = ctm ? ctm.a * ctm.d - ctm.b * ctm.c : NaN;
+        var largestScale = Math.sqrt((squareSum + Math.sqrt(Math.max(0, Math.pow(squareSum, 2) - 4 * Math.pow(determinant, 2)))) / 2);
+        var screenStrokeWidth = Number.parseFloat(style.strokeWidth) * largestScale;
+        var thinAxisLine = (chrome === "axis" || chrome === "grid") && tag1 === "line" && (rect.width === 0 || rect.height === 0) && Number.isFinite(screenStrokeWidth) && screenStrokeWidth <= 1 && screenStrokeWidth > 0 && !item1.unmeasurable;
+        if (thinAxisLine) sample.chrome.push({
+          ...item1,
+          label: `${chrome} line`
+        });else sample.unaccountedPaint.push({
+          ...item1,
+          unmeasurable: "unsupported-paint"
+        });
+      }
+    } catch (err) {
+      _didIteratorError3 = true;
+      _iteratorError3 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+          _iterator3.return();
+        }
+      } finally {
+        if (_didIteratorError3) {
+          throw _iteratorError3;
+        }
+      }
+    }
+    if (sample.kind === "bar" && marks.length > 0 && marks.every(function (mark2, index3) {
+      return (
+        // A bar path that declares its box (value-end rounding, MPO-56)
+        // paints inside that box just as a rect does.
+        (mark2.tagName.toLowerCase() === "rect" || mark2.tagName.toLowerCase() === "path" && mark2.hasAttribute("data-mpo-chart-bar")) && getComputedStyle(mark2).stroke === "none" && !sample.marks[index3].unmeasurable
+      );
+    })) {
+      var minimumGapPx = Infinity;
+      var bounds = marks.map(function (mark2) {
+        return mark2.getBoundingClientRect();
+      });
+      for (var i = 0; i < bounds.length; i++) for (var j = i + 1; j < bounds.length; j++) {
+        var a = bounds[i];
+        var b = bounds[j];
+        var dx = Math.max(0, a.left - b.right, b.left - a.right);
+        var dy = Math.max(0, a.top - b.bottom, b.top - a.bottom);
+        minimumGapPx = Math.min(minimumGapPx, Math.hypot(dx, dy) * window.devicePixelRatio);
+      }
+      sample.separation.method = "rect-bounds";
+      sample.separation.minimumGapPx = Number.isFinite(minimumGapPx) ? minimumGapPx : 2;
+    }
+    if (sample.kind === "area") (_unmeasurable = (_sample = sample).unmeasurable) !== null && _unmeasurable !== void 0 ? _unmeasurable : _sample.unmeasurable = "unsupported-overlap";
+  }
+  function collectText(el, key2, cs) {
+    var directText = [];
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = Array.from(el.childNodes)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var child2 = _step2.value;
+        var _child_textContent;
+        if (child2.nodeType === 3 && ((_child_textContent = child2.textContent) !== null && _child_textContent !== void 0 ? _child_textContent : "").trim().length > 0) {
+          directText.push(child2);
+        }
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+    if (directText.length === 0) return void 0;
+    var range = document.createRange();
+    range.setStartBefore(directText[0]);
+    range.setEndAfter(directText[directText.length - 1]);
+    var textRect = range.getBoundingClientRect();
+    if (!(textRect.width > 0 && textRect.height > 0)) return void 0;
+    var opacity = effectiveOpacity(el);
+    if (opacity > 0.05 && cs.visibility !== "hidden") {
+      var ink = parseCssColor(cs.color);
+      var backdrop = effectiveBackground(el);
+      if (ink) {
+        var _parseCssColor, _directText__textContent;
+        var baseParsed = (_parseCssColor = parseCssColor(backdrop.hex)) !== null && _parseCssColor !== void 0 ? _parseCssColor : [255, 255, 255, 1];
+        var inkOpaque = toHex(ink[3] >= 0.999 ? [ink[0], ink[1], ink[2]] : blend(ink, [baseParsed[0], baseParsed[1], baseParsed[2]]));
+        textSamples.push({
+          key: key2,
+          text: ((_directText__textContent = directText[0].textContent) !== null && _directText__textContent !== void 0 ? _directText__textContent : "").trim().slice(0, 60),
+          color: inkOpaque,
+          background: backdrop.hex,
+          backgroundResolved: backdrop.resolved,
+          overImage: backdrop.overImage,
+          fontSizePx: Number.parseFloat(cs.fontSize) || 0,
+          fontWeightNum: Number.parseFloat(cs.fontWeight) || 400,
+          rect: toRect(textRect)
+        });
+      }
+    }
+    return toRect(textRect);
+  }
+  function boxedChildren(el, path) {
+    var out = [];
+    var counts2 = {};
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = Array.from(el.children)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var child2 = _step2.value;
+        var tag = child2.tagName.toLowerCase();
+        if (SKIP_TAGS.has(tag)) continue;
+        if (child2.namespaceURI === "http://www.w3.org/2000/svg" && tag !== "svg") continue;
+        var cs = getComputedStyle(child2);
+        if (cs.display === "none") continue;
+        if (cs.display === "contents") {
+          var _counts_tag;
+          var index2 = (_counts_tag = counts2[tag]) !== null && _counts_tag !== void 0 ? _counts_tag : 0;
+          counts2[tag] = index2 + 1;
+          collectText(child2, `${path}/${tag}:${index2}~contents`, cs);
+          var _iteratorNormalCompletion12 = true,
+            _didIteratorError12 = false,
+            _iteratorError12 = void 0;
+          try {
+            for (var _iterator12 = boxedChildren(child2, path)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+              var grandchild = _step12.value;
+              out.push(grandchild);
+            }
+          } catch (err) {
+            _didIteratorError12 = true;
+            _iteratorError12 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+                _iterator12.return();
+              }
+            } finally {
+              if (_didIteratorError12) {
+                throw _iteratorError12;
+              }
+            }
+          }
+          continue;
+        }
+        out.push(child2);
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+    return out;
+  }
+  function visit(el, path) {
+    var _el_parentElement;
+    var tag = el.tagName.toLowerCase();
+    var cs = getComputedStyle(el);
+    var rect = el.getBoundingClientRect();
+    var props = {};
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = GEOMETRY_PROPS[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var prop = _step2.value;
+        props[prop] = cs[prop];
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+    var entry = {
+      key: path,
+      tag,
+      rect: toRect(rect),
+      props
+    };
+    var textRect = collectText(el, path, cs);
+    if (textRect) entry.textRect = textRect;
+    if (tag === "svg" && !((_el_parentElement = el.parentElement) === null || _el_parentElement === void 0 ? void 0 : _el_parentElement.closest("svg"))) {
+      capturedSvgRoots.add(el);
+      if (el.hasAttribute("data-mpo-chart")) collectChart(el, path);else collectIcon(el, path, cs);
+    }
+    geometry.push(entry);
+    var counts2 = {};
+    var _iteratorNormalCompletion12 = true,
+      _didIteratorError12 = false,
+      _iteratorError12 = void 0;
+    try {
+      for (var _iterator12 = boxedChildren(el, path)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+        var child2 = _step12.value;
+        var _counts_childTag2;
+        var childTag2 = child2.tagName.toLowerCase();
+        var index2 = (_counts_childTag2 = counts2[childTag2]) !== null && _counts_childTag2 !== void 0 ? _counts_childTag2 : 0;
+        counts2[childTag2] = index2 + 1;
+        visit(child2, `${path}/${childTag2}:${index2}`);
+      }
+    } catch (err) {
+      _didIteratorError12 = true;
+      _iteratorError12 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+          _iterator12.return();
+        }
+      } finally {
+        if (_didIteratorError12) {
+          throw _iteratorError12;
+        }
+      }
+    }
+  }
+  if (root) {
+    var counts = {};
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = boxedChildren(root, "")[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var child = _step.value;
+        var _counts_childTag;
+        var childTag = child.tagName.toLowerCase();
+        var index = (_counts_childTag = counts[childTag]) !== null && _counts_childTag !== void 0 ? _counts_childTag : 0;
+        counts[childTag] = index + 1;
+        visit(child, `${childTag}:${index}`);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    var svgRoots = Array.from(root.querySelectorAll("svg")).filter(function (svg2) {
+      var _svg_parentElement;
+      return !((_svg_parentElement = svg2.parentElement) === null || _svg_parentElement === void 0 ? void 0 : _svg_parentElement.closest("svg"));
+    });
+    svgRootCount = svgRoots.length;
+    var _iteratorNormalCompletion1 = true,
+      _didIteratorError1 = false,
+      _iteratorError1 = void 0;
+    try {
+      for (var _iterator1 = svgRoots.entries()[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+        var [index1, svg] = _step1.value;
+        if (capturedSvgRoots.has(svg)) continue;
+        var key = `unpainted-svg:${index1}`;
+        if (svg.hasAttribute("data-mpo-chart")) collectChart(svg, key);else collectIcon(svg, key, getComputedStyle(svg));
+      }
+    } catch (err) {
+      _didIteratorError1 = true;
+      _iteratorError1 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+          _iterator1.return();
+        }
+      } finally {
+        if (_didIteratorError1) {
+          throw _iteratorError1;
+        }
+      }
+    }
+  }
+  return {
+    storyRendered,
+    geometry,
+    textSamples,
+    iconSamples,
+    chartSamples,
+    svgRootCount
+  };
+}
+function diffGeometry(before, after) {
+  var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  var _options_epsilonPx;
+  var epsilon = (_options_epsilonPx = options.epsilonPx) !== null && _options_epsilonPx !== void 0 ? _options_epsilonPx : 0;
+  var byKey = new Map(before.geometry.map(function (g) {
+    return [g.key, g];
+  }));
+  var seen = /* @__PURE__ */new Set();
+  var moves = [];
+  var addedKeys = [];
+  var rectDiffers = function rectDiffers2(a, b) {
+    return Math.abs(a.x - b.x) > epsilon || Math.abs(a.y - b.y) > epsilon || Math.abs(a.w - b.w) > epsilon || Math.abs(a.h - b.h) > epsilon;
+  };
+  var formatRect = function formatRect2(r) {
+    return `${r.x},${r.y} ${r.w}x${r.h}`;
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = after.geometry[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var curr = _step.value;
+      var prev = byKey.get(curr.key);
+      if (!prev) {
+        addedKeys.push(curr.key);
+        continue;
+      }
+      seen.add(curr.key);
+      if (rectDiffers(prev.rect, curr.rect)) {
+        moves.push({
+          key: curr.key,
+          property: "rect",
+          before: formatRect(prev.rect),
+          after: formatRect(curr.rect)
+        });
+      }
+      if (prev.textRect && curr.textRect && rectDiffers(prev.textRect, curr.textRect)) {
+        moves.push({
+          key: curr.key,
+          property: "textRect",
+          before: formatRect(prev.textRect),
+          after: formatRect(curr.textRect)
+        });
+      } else if (!!prev.textRect !== !!curr.textRect) {
+        moves.push({
+          key: curr.key,
+          property: "textRect",
+          before: prev.textRect ? formatRect(prev.textRect) : "(none)",
+          after: curr.textRect ? formatRect(curr.textRect) : "(none)"
+        });
+      }
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = Object.keys(prev.props)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var prop = _step1.value;
+          if (prev.props[prop] !== curr.props[prop]) {
+            var _curr_props_prop;
+            moves.push({
+              key: curr.key,
+              property: prop,
+              before: prev.props[prop],
+              after: (_curr_props_prop = curr.props[prop]) !== null && _curr_props_prop !== void 0 ? _curr_props_prop : "(missing)"
+            });
+          }
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var removedKeys = before.geometry.filter(function (g) {
+    return !seen.has(g.key);
+  }).map(function (g) {
+    return g.key;
+  });
+  return {
+    identical: moves.length === 0 && addedKeys.length === 0 && removedKeys.length === 0,
+    removedKeys,
+    addedKeys,
+    moves
+  };
+}
+function evaluateTextContrast(samples) {
+  var measured = 0;
+  var unmeasurable = 0;
+  var violations = [];
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = samples[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var sample = _step.value;
+      if (!sample.backgroundResolved) {
+        unmeasurable++;
+        continue;
+      }
+      var large = sample.fontSizePx >= 24 || sample.fontSizePx >= 18.66 && sample.fontWeightNum >= 700;
+      var required = large ? minContrastRatio : aaTextContrastRatio;
+      try {
+        var report = measureContrast({
+          foreground: sample.color,
+          background: sample.background,
+          floor: required,
+          label: sample.key
+        });
+        measured++;
+        if (!report.pass) {
+          violations.push({
+            key: sample.key,
+            text: sample.text,
+            color: report.foreground,
+            background: report.background,
+            ratio: report.ratio,
+            required: report.floor
+          });
+        }
+      } catch (unused) {
+        unmeasurable++;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return {
+    measured,
+    unmeasurable,
+    violations
+  };
+}
+function evaluateIconContrast(samples) {
+  var result = {
+    ok: true,
+    candidates: 0,
+    measured: 0,
+    violations: [],
+    unverified: [],
+    excludedDisabled: 0,
+    excludedDecorative: 0,
+    excludedHidden: 0
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = samples[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var sample = _step.value;
+      var _sample_unmeasurable;
+      if (sample.status === "disabled-control") {
+        result.excludedDisabled++;
+        continue;
+      }
+      if (sample.status === "decorative-standalone") {
+        result.excludedDecorative++;
+        continue;
+      }
+      if (sample.status === "hidden") {
+        result.excludedHidden++;
+        continue;
+      }
+      result.candidates++;
+      var reason = (_sample_unmeasurable = sample.unmeasurable) !== null && _sample_unmeasurable !== void 0 ? _sample_unmeasurable : !sample.backgroundResolved ? "unresolved-backdrop" : !sample.paint ? "no-paint" : void 0;
+      if (reason) {
+        result.unverified.push({
+          key: sample.key,
+          context: sample.context,
+          reason
+        });
+        continue;
+      }
+      try {
+        var contrast = measureContrast({
+          foreground: sample.paint,
+          background: sample.background,
+          floor: minContrastRatio,
+          label: sample.key
+        });
+        result.measured++;
+        if (!contrast.pass) result.violations.push({
+          key: sample.key,
+          context: sample.context,
+          paint: contrast.foreground,
+          background: contrast.background,
+          ratio: contrast.ratio,
+          required: contrast.floor
+        });
+      } catch (unused) {
+        result.unverified.push({
+          key: sample.key,
+          context: sample.context,
+          reason: "unsupported-paint"
+        });
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  result.ok = result.violations.length === 0 && result.unverified.length === 0;
+  return result;
+}
+function iconContrastSignatures(result) {
+  return [...result.violations.map(function (item) {
+    return `${item.key} (${item.context}) icon ${item.paint} on ${item.background} = ${item.ratio}:1 (floor ${item.required})`;
+  }), ...result.unverified.map(function (item) {
+    return `${item.key} (${item.context}) icon UNVERIFIED: ${item.reason}`;
+  })];
+}
+function evaluateChartProof(samples) {
+  var result = {
+    ok: true,
+    candidates: samples.length,
+    measured: 0,
+    marksMeasured: 0,
+    labelsMeasured: 0,
+    byKind: /* @__PURE__ */Object.create(null),
+    violations: [],
+    unverified: []
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    var _loop = function () {
+      var sample = _step.value;
+      var _result_byKind_sample_kind, _sample_unaccountedPaint;
+      result.byKind[sample.kind] = ((_result_byKind_sample_kind = result.byKind[sample.kind]) !== null && _result_byKind_sample_kind !== void 0 ? _result_byKind_sample_kind : 0) + 1;
+      var unverified = function unverified2(reason) {
+        var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : sample.key,
+          context2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : sample.context;
+        return result.unverified.push({
+          key,
+          context: context2,
+          reason
+        });
+      };
+      if (!["bar", "pie", "donut", "line", "area"].includes(sample.kind)) {
+        unverified("unknown-kind");
+        return "continue";
+      }
+      if (!sample.label.trim()) result.violations.push({
+        key: sample.key,
+        context: sample.context,
+        rule: "missing-label"
+      });
+      if (sample.unmeasurable) unverified(sample.unmeasurable);else if (!sample.backgroundResolved) unverified("unresolved-backdrop");
+      if (!sample.marks.length) unverified("no-marks");
+      var _iteratorNormalCompletion2 = true,
+        _didIteratorError2 = false,
+        _iteratorError2 = void 0;
+      try {
+        for (var _iterator2 = ((_sample_unaccountedPaint = sample.unaccountedPaint) !== null && _sample_unaccountedPaint !== void 0 ? _sample_unaccountedPaint : [])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion2 = (_step1 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var item = _step1.value;
+          unverified("unsupported-paint", item.key, `${sample.context}: ${item.label}`);
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+      if (!sample.datumText.declared || !sample.datumText.complete || sample.datumText.expected <= 0 || sample.datumText.observed !== sample.datumText.expected) unverified("incomplete-datum-text", sample.key, sample.datumText.failure ? `${sample.context}: ${sample.datumText.failure}` : sample.context);
+      var compare = function compare2(paint, background, key, context2, rule, floor) {
+        try {
+          var measured = measureContrast({
+            foreground: paint,
+            background,
+            floor,
+            label: key
+          });
+          if (!measured.pass) result.violations.push({
+            key,
+            context: context2,
+            rule,
+            paint: measured.foreground,
+            background: measured.background,
+            ratio: measured.ratio,
+            required: measured.floor
+          });
+          return true;
+        } catch (unused) {
+          unverified("unsupported-paint", key, context2);
+          return false;
+        }
+      };
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = sample.marks[Symbol.iterator](), _step2; !(_iteratorNormalCompletion1 = (_step2 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var mark = _step2.value;
+          var _mark_unmeasurable;
+          var context = `${sample.context}: ${mark.label}`;
+          if (mark.unmeasurable || !mark.paint) unverified((_mark_unmeasurable = mark.unmeasurable) !== null && _mark_unmeasurable !== void 0 ? _mark_unmeasurable : "no-paint", mark.key, context);else if (compare(mark.paint, mark.background, mark.key, context, "mark-backdrop", minContrastRatio)) result.marksMeasured++;
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      var _iteratorNormalCompletion22 = true,
+        _didIteratorError22 = false,
+        _iteratorError22 = void 0;
+      try {
+        for (var _iterator22 = sample.labels[Symbol.iterator](), _step3; !(_iteratorNormalCompletion22 = (_step3 = _iterator22.next()).done); _iteratorNormalCompletion22 = true) {
+          var label = _step3.value;
+          var _label_unmeasurable;
+          var context1 = `${sample.context}: ${label.label}`;
+          if (label.unmeasurable || !label.paint) unverified((_label_unmeasurable = label.unmeasurable) !== null && _label_unmeasurable !== void 0 ? _label_unmeasurable : "no-paint", label.key, context1);else if (compare(label.paint, label.background, label.key, context1, "axis-text", aaTextContrastRatio)) result.labelsMeasured++;
+        }
+      } catch (err) {
+        _didIteratorError22 = true;
+        _iteratorError22 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion22 && _iterator22.return != null) {
+            _iterator22.return();
+          }
+        } finally {
+          if (_didIteratorError22) {
+            throw _iteratorError22;
+          }
+        }
+      }
+      var separated = (sample.kind === "bar" && sample.separation.method === "rect-bounds" || (sample.kind === "pie" || sample.kind === "donut") && sample.separation.method === "eroded-arc") && Number.isFinite(sample.separation.minimumGapPx) && sample.separation.minimumGapPx >= 2;
+      if (sample.kind === "bar" && !separated) unverified("unverified-separation");
+      if (sample.kind === "pie" || sample.kind === "donut") {
+        if (sample.separation.declared && !separated) unverified("unverified-separation");
+        if (sample.marks.length > 1 && !separated) {
+          for (var i = 0; i < sample.marks.length; i++) {
+            var first = sample.marks[i];
+            var second = sample.marks[(i + 1) % sample.marks.length];
+            if (sample.marks.length === 2 && i === 1) continue;
+            if (first.paint && second.paint && !first.unmeasurable && !second.unmeasurable) compare(first.paint, second.paint, `${first.key}~${second.key}`, `${sample.context}: ${first.label} / ${second.label}`, "adjacent-pair", minContrastRatio);
+          }
+        }
+      }
+      if (!sample.unmeasurable && sample.backgroundResolved && sample.marks.length > 0 && sample.marks.every(function (mark2) {
+        return mark2.paint && !mark2.unmeasurable;
+      })) result.measured++;
+    };
+    for (var _iterator = samples[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  result.ok = result.violations.length === 0 && result.unverified.length === 0;
+  return result;
+}
+function chartProofSignatures(result) {
+  return [...result.violations.map(function (item) {
+    return `${item.key} (${item.context}) chart ${item.rule}${item.ratio === void 0 ? "" : ` ${item.paint} on ${item.background} = ${item.ratio}:1 (floor ${item.required})`}`;
+  }), ...result.unverified.map(function (item) {
+    return `${item.key} (${item.context}) chart UNVERIFIED: ${item.reason}`;
+  })];
+}
+function auditSignatures(violations) {
+  var out = [];
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = violations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var element = _step.value;
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = element.violations[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var violation = _step1.value;
+          out.push(`${element.key ? `[${element.key}] ` : ""}${element.label} :: ${violation}`);
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return out;
+}
+function newEntries(before, after) {
+  var _remaining_get;
+  var remaining = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = before[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var entry = _step.value;
+      remaining.set(entry, ((_remaining_get = remaining.get(entry)) !== null && _remaining_get !== void 0 ? _remaining_get : 0) + 1);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var added = [];
+  var _iteratorNormalCompletion1 = true,
+    _didIteratorError1 = false,
+    _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = after[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var entry1 = _step1.value;
+      var _remaining_get1;
+      var count = (_remaining_get1 = remaining.get(entry1)) !== null && _remaining_get1 !== void 0 ? _remaining_get1 : 0;
+      if (count > 0) remaining.set(entry1, count - 1);else added.push(entry1);
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  return added;
+}
+function offScaleIdentity(signature) {
+  return signature.replace(/-?\d+(?:\.\d+)?px/g, "#px").replace(/(inlineColor: \w+=)"[^"]*"/g, '$1"#colour"').replace(/\.font_[\w-]+/g, ".font_#family");
+}
+function newOffScaleEntries(before, after) {
+  var _pending_get;
+  var added = newEntries(before.map(offScaleIdentity), after.map(offScaleIdentity));
+  var pending = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = added[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var identity = _step.value;
+      pending.set(identity, ((_pending_get = pending.get(identity)) !== null && _pending_get !== void 0 ? _pending_get : 0) + 1);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var named = [];
+  var _iteratorNormalCompletion1 = true,
+    _didIteratorError1 = false,
+    _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = after[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var signature = _step1.value;
+      var _pending_get1;
+      var identity1 = offScaleIdentity(signature);
+      var count = (_pending_get1 = pending.get(identity1)) !== null && _pending_get1 !== void 0 ? _pending_get1 : 0;
+      if (count === 0) continue;
+      pending.set(identity1, count - 1);
+      named.push(signature);
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  return named;
+}
+var namedList = function namedList2(entries) {
+  var limit = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 6;
+  if (entries.length === 0) return "";
+  var shown = entries.slice(0, limit).join("; ");
+  return entries.length > limit ? ` \u2014 new: ${shown}; \u2026 ${entries.length - limit} more` : ` \u2014 new: ${shown}`;
+};
+function evaluateNoBreakage(input) {
+  var failures = [];
+  if (!input.storyRendered) {
+    failures.push("story did not render (empty story root)");
+  }
+  var structuralAdded = input.offScaleSignatures && input.baselineOffScaleSignatures ? newOffScaleEntries(input.baselineOffScaleSignatures, input.offScaleSignatures) : [];
+  if (structuralAdded.length || input.offScaleViolations > input.baselineOffScaleViolations) {
+    failures.push(`constraint audit: ${input.offScaleViolations} off-scale violations (default cell has ${input.baselineOffScaleViolations})${namedList(structuralAdded)}`);
+  }
+  var signature = function signature2(violation) {
+    return `${violation.key} "${violation.text}" ${violation.color} on ${violation.background} = ${violation.ratio}:1 (floor ${violation.required})`;
+  };
+  var contrastAdded = input.baselineContrast ? newEntries(input.baselineContrast.violations.map(signature), input.contrast.violations.map(signature)) : [];
+  if (contrastAdded.length || input.contrast.violations.length > input.baselineContrastViolations) {
+    failures.push(`text contrast: ${input.contrast.violations.length} below-floor text nodes (default cell has ${input.baselineContrastViolations})${namedList(contrastAdded)}`);
+  }
+  if (input.icons === void 0 !== (input.baselineIcons === void 0)) {
+    failures.push("icon contrast: icons and baselineIcons must be supplied together");
+  } else if (input.icons && input.baselineIcons) {
+    var newIconFindings = newEntries(iconContrastSignatures(input.baselineIcons), iconContrastSignatures(input.icons));
+    if (newIconFindings.length > 0) {
+      failures.push(`icon contrast: ${newIconFindings.length} new findings${namedList(newIconFindings)}`);
+    }
+  }
+  if (input.charts === void 0 !== (input.baselineCharts === void 0)) {
+    failures.push("chart proof: charts and baselineCharts must be supplied together");
+  } else if (input.charts && input.baselineCharts) {
+    var added = newEntries(chartProofSignatures(input.baselineCharts), chartProofSignatures(input.charts));
+    if (added.length) failures.push(`chart proof: ${added.length} new findings${namedList(added)}`);
+  }
+  return {
+    ok: failures.length === 0,
+    failures
+  };
+}
+export { auditSignatures, captureMatrixSnapshot, chartProofSignatures, diffGeometry, evaluateChartProof, evaluateIconContrast, evaluateNoBreakage, evaluateTextContrast, iconContrastSignatures, offScaleIdentity };
+//# sourceMappingURL=themeMatrix.native.js.map