@hawkeyexl/manni 4.3.1 → 4.4.1

package/dist/cli-6HIDIFVT.js

@@ -0,0 +1,1203 @@
+#!/usr/bin/env node
+import {
+  SEVERITIES,
+  SEVERITY_LIST,
+  isSeverity,
+  meetsSeverity
+} from "./chunk-77AINBYM.js";
+import {
+  fail
+} from "./chunk-YEUYKR62.js";
+import {
+  palette,
+  shouldColor
+} from "./chunk-RNVYGWIC.js";
+import {
+  escapeWorkflowCommandMessage,
+  escapeWorkflowCommandProperty
+} from "./chunk-MNH7QO4Z.js";
+import {
+  FAMILY_CONFIG_NAMES,
+  findConfigFile,
+  matchesFileGlob,
+  readConfigFile,
+  selectCollections
+} from "./chunk-Q35YIDBV.js";
+import {
+  package_default
+} from "./chunk-UJCVAWP7.js";
+import {
+  programName
+} from "./chunk-OWBRDNRZ.js";
+import {
+  ToolError
+} from "./chunk-G3T47CFV.js";
+import "./chunk-2H7UOFLK.js";
+
+// src/a11y/cli.ts
+import { Command } from "commander";
+
+// src/a11y/types.ts
+var A11yError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "A11yError";
+  }
+};
+var AXE_IMPACTS = ["minor", "moderate", "serious", "critical"];
+function isAxeImpact(value) {
+  return AXE_IMPACTS.includes(value);
+}
+
+// src/a11y/core/url.ts
+function normalizeUrl(url) {
+  const parsed = parse(url);
+  if (parsed === null) throw new A11yError(`Not a valid URL: "${url}".`);
+  parsed.hash = "";
+  return parsed.href;
+}
+function dedupeKey(url) {
+  const parsed = new URL(normalizeUrl(url));
+  if (parsed.pathname.length > 1 && parsed.pathname.endsWith("/")) {
+    parsed.pathname = parsed.pathname.slice(0, -1);
+  }
+  return parsed.href;
+}
+function isHttpUrl(url) {
+  const parsed = parse(url);
+  return parsed !== null && isHttpProtocol(parsed);
+}
+function sameHost(a, b) {
+  const left = parse(a);
+  const right = parse(b);
+  if (left === null || right === null) return false;
+  return left.hostname.toLowerCase() === right.hostname.toLowerCase() && left.port === right.port;
+}
+function isPageLink(url) {
+  const parsed = parse(url);
+  if (parsed === null || !isHttpProtocol(parsed)) return false;
+  const last = parsed.pathname.slice(parsed.pathname.lastIndexOf("/") + 1);
+  const dot = last.lastIndexOf(".");
+  if (dot === -1) return true;
+  return !ASSET_EXTENSIONS.has(last.slice(dot).toLowerCase());
+}
+var ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pdf",
+  ".zip",
+  ".gz",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".webp",
+  ".avif",
+  ".ico",
+  ".css",
+  ".js",
+  ".mjs",
+  ".map",
+  ".json",
+  ".xml",
+  ".txt",
+  ".mp3",
+  ".mp4",
+  ".webm",
+  ".woff",
+  ".woff2",
+  ".ttf"
+]);
+function parse(url) {
+  try {
+    return new URL(url);
+  } catch {
+    return null;
+  }
+}
+function isHttpProtocol(url) {
+  return url.protocol === "http:" || url.protocol === "https:";
+}
+
+// src/a11y/core/crawl.ts
+async function crawl(opts, analyzer) {
+  const frontier = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const excluded = /* @__PURE__ */ new Set();
+  const progress = opts.onProgress ?? (() => void 0);
+  const enqueue = (raw, source) => {
+    let url;
+    let key;
+    try {
+      url = normalizeUrl(raw);
+      key = dedupeKey(url);
+    } catch {
+      return { as: "invalid" };
+    }
+    if (source !== "seed" && !isPageLink(url)) return { as: "asset" };
+    if (!opts.seeds.some((seed) => sameHost(seed, url))) return { as: "off-host" };
+    const pattern = opts.exclude?.match(url) ?? null;
+    if (pattern !== null) {
+      excluded.add(key);
+      return { as: "excluded", pattern };
+    }
+    if (seen.has(key)) return { as: "seen" };
+    seen.add(key);
+    frontier.push({ url, key, source });
+    return { as: "queued" };
+  };
+  const landed = (finalUrl) => {
+    if (finalUrl === void 0) return;
+    try {
+      const key = dedupeKey(finalUrl);
+      seen.add(key);
+      visited.add(key);
+    } catch {
+    }
+  };
+  for (const seed of opts.seeds) enqueue(seed, "seed");
+  if (opts.crawl) for (const url of opts.extra) enqueue(url, "sitemap");
+  if (excluded.size > 0) {
+    progress({ kind: "excluded", urls: excluded.size, patterns: opts.exclude?.patterns.length ?? 0 });
+  }
+  const pages = [];
+  const redirects = [];
+  let duplicates = 0;
+  const capped = () => opts.maxPages !== void 0 && pages.length >= opts.maxPages;
+  for (let next = 0; next < frontier.length && !capped(); next++) {
+    const candidate = frontier[next];
+    if (candidate === void 0) break;
+    const { url, key, source } = candidate;
+    if (visited.has(key)) {
+      duplicates += 1;
+      continue;
+    }
+    visited.add(key);
+    const index = pages.length + 1;
+    if (pages.length + redirects.length === 0) progress({ kind: "browser" });
+    progress({ kind: "page", index, queued: frontier.length, url });
+    try {
+      const analyzed = await analyzer.analyze(url, opts.analyze);
+      if ("redirect" in analyzed) {
+        const to = normalized(analyzed.redirect);
+        redirects.push({ url, to, source });
+        progress({ kind: "redirected", index, url, to });
+        const outcome2 = enqueue(to, source);
+        if (source === "seed") {
+          if (!isHttpUrl(to)) {
+            throw new A11yError(`${url} redirects to ${to}, which is not an http(s) URL.`);
+          }
+          if (outcome2.as === "off-host") {
+            throw new A11yError(`${url} redirects to ${to}, which is on another host. Check ${to} instead.`);
+          }
+          if (outcome2.as === "excluded") {
+            throw new A11yError(`${outcome2.pattern.source} excludes ${to}, where the seed ${url} redirects.`);
+          }
+        }
+        continue;
+      }
+      pages.push({ ...analyzed.result, url, source });
+      landed(analyzed.finalUrl);
+      if (opts.crawl) for (const link of analyzed.links) enqueue(link, "link");
+      progress({ kind: "checked", index, url, violations: analyzed.result.violations.length });
+    } catch (err) {
+      if (source === "seed") throw err;
+      const error = err instanceof Error ? err.message : String(err);
+      pages.push({ url, source, violations: [], passes: 0, incomplete: 0, error });
+      progress({ kind: "checked", index, url, violations: 0, error });
+    }
+  }
+  const skipped = frontier.length - pages.length - duplicates - redirects.length;
+  progress({ kind: "done", checked: pages.length, skipped });
+  return {
+    pages,
+    discovered: frontier.length,
+    skipped,
+    duplicates,
+    redirects,
+    excluded: excluded.size
+  };
+}
+function normalized(url) {
+  try {
+    return normalizeUrl(url);
+  } catch {
+    return url;
+  }
+}
+
+// src/a11y/core/exclude.ts
+var MUST_START_WITH_SLASH = 'must start with "/": it matches a URL path.';
+function isUrlPathGlob(pattern) {
+  return pattern.startsWith("/");
+}
+function excludePath(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  const path = parsed.pathname;
+  return path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function createExcludeFilter(patterns) {
+  const list = [...patterns];
+  const match = (url) => {
+    if (list.length === 0) return null;
+    const path = excludePath(url);
+    if (path === null) return null;
+    return list.find((pattern) => matchesFileGlob(path, pattern.glob)) ?? null;
+  };
+  return {
+    patterns: list,
+    match,
+    matches: (url) => match(url) !== null
+  };
+}
+
+// src/a11y/core/seeds.ts
+var NO_SEEDS_MESSAGE = "No URLs to check. Pass one or more, set url: on a collection, or set a11y.urls in manni.config.yaml.";
+var CONFIG_NAME = "manni.config.yaml";
+function resolveSeeds(sources) {
+  const { urls, collections: names, declared } = sources;
+  if (names.length > 0) {
+    if (urls.length > 0) {
+      throw new A11yError(
+        "--collection selects a configured collection; it cannot be combined with URLs."
+      );
+    }
+    if (sources.source == null && declared.length === 0) {
+      throw new A11yError("--collection needs a config file to select from.");
+    }
+    const selected = selectCollections(
+      declared,
+      names,
+      sources.source ?? CONFIG_NAME,
+      (message) => new A11yError(message)
+    );
+    const seeds = [];
+    for (const collection of selected) {
+      if (collection.url === void 0) {
+        throw new A11yError(`collection "${collection.name}" has no url: to check.`);
+      }
+      seeds.push(collection.url);
+    }
+    return unique(seeds);
+  }
+  if (urls.length > 0) return [...urls];
+  const configUrls = sources.configUrls ?? [];
+  if (configUrls.length > 0) return [...configUrls];
+  const published = unique(
+    declared.flatMap((collection) => collection.url === void 0 ? [] : [collection.url])
+  );
+  if (published.length > 0) return published;
+  throw new A11yError(NO_SEEDS_MESSAGE);
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+
+// src/a11y/core/sitemap.ts
+import { DOMParser } from "@xmldom/xmldom";
+var MAX_INDEX_DEPTH = 3;
+var MAX_CHILD_SITEMAPS = 50;
+var FETCH_TIMEOUT_MS = 1e4;
+var defaultFetcher = (url) => fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+var WELL_KNOWN_SITEMAP_FILES = ["sitemap.xml", "sitemap-index.xml", "sitemap_index.xml"];
+async function discoverSitemap(seed, fetcher = defaultFetcher) {
+  const origin = new URL(seed).origin;
+  const candidates = await robotsSitemaps(`${origin}/robots.txt`, fetcher);
+  for (const candidate of wellKnownCandidates(seed)) {
+    if (!candidates.includes(candidate)) candidates.push(candidate);
+  }
+  for (const candidate of candidates) {
+    const parsed = await fetchSitemap(candidate, fetcher);
+    if (parsed === null) continue;
+    const walk = { fetcher, seen: /* @__PURE__ */ new Set([candidate]), childBudget: MAX_CHILD_SITEMAPS };
+    const locs = await expand(parsed, 0, walk);
+    return { source: candidate, urls: pageUrls(seed, locs) };
+  }
+  return { source: null, urls: [] };
+}
+function parseSitemapXml(text) {
+  if (text.trim() === "") return null;
+  let root;
+  try {
+    const doc = new DOMParser({ onError: () => void 0 }).parseFromString(text, "text/xml");
+    root = doc.documentElement;
+  } catch {
+    return null;
+  }
+  if (root === null) return null;
+  const kind = root.localName;
+  if (kind !== "sitemapindex" && kind !== "urlset") return null;
+  const entry = kind === "sitemapindex" ? "sitemap" : "url";
+  const locs = [];
+  for (const child of childElements(root, entry)) {
+    for (const loc of childElements(child, "loc")) {
+      const value = (loc.textContent ?? "").trim();
+      if (value !== "") locs.push(value);
+    }
+  }
+  return { kind: kind === "sitemapindex" ? "index" : "urlset", locs };
+}
+function childElements(node, name) {
+  const out = [];
+  for (let n = node.firstChild; n !== null; n = n.nextSibling) {
+    if (n.nodeType === 1 && n.localName === name) out.push(n);
+  }
+  return out;
+}
+async function expand(parsed, depth, walk) {
+  if (parsed.kind === "urlset") return parsed.locs;
+  if (depth >= MAX_INDEX_DEPTH) return [];
+  const out = [];
+  for (const child of parsed.locs) {
+    if (walk.childBudget <= 0) break;
+    if (!isHttpUrl(child) || walk.seen.has(child)) continue;
+    walk.seen.add(child);
+    walk.childBudget -= 1;
+    const nested = await fetchSitemap(child, walk.fetcher);
+    if (nested === null) continue;
+    out.push(...await expand(nested, depth + 1, walk));
+  }
+  return out;
+}
+function wellKnownCandidates(seed) {
+  const url = new URL(seed);
+  const directories = ancestorDirectories(url.pathname);
+  return directories.flatMap(
+    (dir) => WELL_KNOWN_SITEMAP_FILES.map((file) => `${url.origin}${dir}${file}`)
+  );
+}
+function ancestorDirectories(pathname) {
+  let dir = pathname.slice(0, pathname.lastIndexOf("/") + 1);
+  const out = [];
+  for (; ; ) {
+    out.push(dir);
+    if (dir === "/") return out;
+    const parent = dir.slice(0, dir.lastIndexOf("/", dir.length - 2) + 1);
+    dir = parent === "" ? "/" : parent;
+  }
+}
+async function robotsSitemaps(url, fetcher) {
+  const text = await fetchText(url, fetcher);
+  if (text === null) return [];
+  const out = [];
+  for (const line of text.split(/\r?\n/)) {
+    const match = /^\s*sitemap\s*:\s*(\S+)/i.exec(line);
+    const candidate = match?.[1];
+    if (candidate !== void 0 && isHttpUrl(candidate) && !out.includes(candidate)) {
+      out.push(candidate);
+    }
+  }
+  return out;
+}
+async function fetchSitemap(url, fetcher) {
+  const text = await fetchText(url, fetcher);
+  return text === null ? null : parseSitemapXml(text);
+}
+async function fetchText(url, fetcher) {
+  try {
+    const response = await fetcher(url);
+    if (!response.ok) return null;
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+function pageUrls(seed, locs) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const loc of locs) {
+    if (!isHttpUrl(loc) || !sameHost(seed, loc) || !isPageLink(loc)) continue;
+    const url = normalizeUrl(loc);
+    if (seen.has(url)) continue;
+    seen.add(url);
+    out.push(url);
+  }
+  return out;
+}
+
+// src/a11y/commands/check.ts
+var CHECK_DEFAULTS = Object.freeze({
+  crawl: true,
+  tags: [],
+  severity: "notice",
+  timeout: 3e4,
+  exclude: []
+});
+async function runCheck(opts, deps) {
+  const { analyzer } = deps;
+  try {
+    if (opts.urls.length === 0) {
+      throw new A11yError(NO_SEEDS_MESSAGE);
+    }
+    for (const url of opts.urls) {
+      if (!isHttpUrl(url)) throw new A11yError(`Not an http(s) URL: "${url}".`);
+    }
+    const seeds = opts.urls.map(normalizeUrl);
+    const exclude = createExcludeFilter(opts.exclude);
+    const contradictions = seeds.map((seed) => {
+      const pattern = exclude.match(seed);
+      return pattern === null ? null : `${pattern.source} excludes the seed ${seed}.`;
+    }).filter((line) => line !== null);
+    if (contradictions.length > 0) throw new A11yError(contradictions.join("\n"));
+    let sitemap = { source: null, urls: [] };
+    const first = seeds[0];
+    if (opts.crawl && first !== void 0) {
+      sitemap = await discoverSitemap(first, deps.fetcher);
+      deps.onProgress?.({ kind: "sitemap", source: sitemap.source, urls: sitemap.urls.length });
+    }
+    const outcome2 = await crawl(
+      {
+        seeds,
+        crawl: opts.crawl,
+        maxPages: opts.maxPages,
+        extra: sitemap.urls,
+        exclude,
+        analyze: { tags: opts.tags, timeout: opts.timeout },
+        onProgress: deps.onProgress
+      },
+      analyzer
+    );
+    const results = outcome2.pages.map((page) => finishPage(page, opts.severity));
+    return {
+      results,
+      redirects: outcome2.redirects,
+      summary: summarize(results, outcome2, sitemap, opts.crawl)
+    };
+  } finally {
+    await analyzer.close();
+  }
+}
+function finishPage(page, floor) {
+  if (page.error !== void 0) return { ...page, violations: [], score: null };
+  const violations = page.violations.filter((v) => meetsSeverity(v.severity, floor));
+  const applicable = page.passes + violations.length;
+  const score = applicable === 0 ? null : Math.round(100 * page.passes / applicable);
+  return { ...page, violations, score };
+}
+function fails(page) {
+  return page.error !== void 0 || page.violations.length > 0;
+}
+function summarize(results, { discovered, skipped, duplicates, redirects, excluded }, sitemap, crawl2) {
+  const bySeverity = { notice: 0, warning: 0, error: 0 };
+  let failed = 0;
+  let violations = 0;
+  for (const page of results) {
+    if (fails(page)) failed += 1;
+    for (const violation of page.violations) {
+      violations += 1;
+      bySeverity[violation.severity] += 1;
+    }
+  }
+  return {
+    discovered,
+    checked: results.length,
+    skipped,
+    duplicates,
+    redirects: redirects.length,
+    excluded,
+    failed,
+    violations,
+    bySeverity,
+    sitemap: sitemap.source,
+    // The count the progress line already reported as `(N pages)`, so the
+    // report cannot disagree with the narration that preceded it.
+    sitemapPages: sitemap.urls.length,
+    crawl: crawl2
+  };
+}
+
+// src/a11y/core/analyzer.ts
+import { AxeBuilder } from "@axe-core/playwright";
+import {
+  chromium
+} from "playwright-core";
+var NO_BROWSER_MESSAGE = "No browser found. Install one with `npx playwright install chromium`, or install Google Chrome or Microsoft Edge.";
+var CHANNELS = ["chrome", "msedge", "chromium"];
+function launch(channel) {
+  return channel === "chromium" ? chromium.launch({ headless: true }) : chromium.launch({ channel, headless: true });
+}
+async function launchAny() {
+  for (const channel of CHANNELS) {
+    try {
+      return { browser: await launch(channel), channel };
+    } catch {
+    }
+  }
+  return null;
+}
+function createPlaywrightAnalyzer() {
+  let session = null;
+  let current = null;
+  const open = () => {
+    session ??= (async () => {
+      const found = await launchAny();
+      if (found === null) throw new A11yError(NO_BROWSER_MESSAGE);
+      const context = await found.browser.newContext();
+      return { browser: found.browser, context };
+    })();
+    return session;
+  };
+  return {
+    async analyze(url, opts) {
+      const { context } = await open();
+      const page = await context.newPage();
+      const previous = current;
+      current = page;
+      await previous?.close().catch(() => void 0);
+      const navigations = [];
+      const onRequest = (request) => {
+        if (request.isNavigationRequest() && request.frame() === page.mainFrame() && request.redirectedFrom() === null) {
+          navigations.push(request);
+        }
+      };
+      page.on("request", onRequest);
+      try {
+        return await analyzePage(page, url, opts, navigations);
+      } finally {
+        page.off("request", onRequest);
+      }
+    },
+    async close() {
+      if (session === null) return;
+      const pending = session;
+      session = null;
+      current = null;
+      try {
+        const { browser } = await pending;
+        await browser.close();
+      } catch {
+      }
+    }
+  };
+}
+async function analyzePage(page, url, opts, navigations) {
+  let response;
+  try {
+    response = await page.goto(url, { waitUntil: "load", timeout: opts.timeout });
+  } catch (err) {
+    throw new A11yError(`Could not load ${url}: ${reason(err)}`);
+  }
+  const loaded = response?.url() ?? page.url();
+  const nextNavigation = () => {
+    let first = response?.request() ?? null;
+    for (let from = first?.redirectedFrom() ?? null; from !== null; from = from.redirectedFrom()) {
+      first = from;
+    }
+    const own = first === null ? 0 : navigations.indexOf(first);
+    return own === -1 ? void 0 : navigations[own + 1];
+  };
+  const destination = () => nextNavigation()?.url() ?? page.url();
+  const navigatedAway = async () => {
+    if (nextNavigation() === void 0 && samePage(page.url(), loaded)) return null;
+    try {
+      await page.waitForURL((u) => !samePage(u.href, loaded), {
+        waitUntil: "commit",
+        timeout: opts.timeout
+      });
+      return { redirect: destination() };
+    } catch {
+      return null;
+    }
+  };
+  let read;
+  try {
+    read = await page.evaluate(readPage);
+  } catch (err) {
+    const moved = await navigatedAway();
+    if (moved !== null) return moved;
+    throw new A11yError(`Could not analyze ${url}: ${reason(err)}`);
+  }
+  const refresh = refreshTarget(read.refresh, page.url());
+  if (refresh !== null) return { redirect: refresh };
+  let builder = new AxeBuilder({ page });
+  if (opts.tags.length > 0) builder = builder.withTags(opts.tags);
+  let results;
+  try {
+    results = await builder.analyze();
+  } catch (err) {
+    const moved = await navigatedAway();
+    if (moved !== null) return moved;
+    throw new A11yError(`Could not analyze ${url}: ${reason(err)}`);
+  }
+  if (!samePage(page.url(), loaded)) return { redirect: destination() };
+  return {
+    result: {
+      url,
+      violations: results.violations.map(toViolation),
+      passes: results.passes.length,
+      incomplete: results.incomplete.length
+    },
+    links: read.links,
+    finalUrl: page.url()
+  };
+}
+function readPage() {
+  const doc = globalThis.document;
+  return {
+    links: Array.from(doc.querySelectorAll("a[href]"), (a) => a.href),
+    refresh: doc.querySelector('meta[http-equiv="refresh" i]')?.getAttribute("content") ?? null
+  };
+}
+function refreshUrl(content) {
+  const match = /^\s*[\d.]*\s*[;,]\s*(?:url\s*=\s*)?(.*)$/is.exec(content);
+  let target = match?.[1]?.trim() ?? "";
+  const quote = target[0];
+  if (quote === "'" || quote === '"') {
+    const end = target.indexOf(quote, 1);
+    target = (end === -1 ? target.slice(1) : target.slice(1, end)).trim();
+  }
+  return target === "" ? null : target;
+}
+function refreshTarget(content, base) {
+  if (content === null) return null;
+  const target = refreshUrl(content);
+  if (target === null) return null;
+  let to;
+  try {
+    to = new URL(target, base).href;
+  } catch {
+    return null;
+  }
+  return samePage(to, base) ? null : to;
+}
+function samePage(a, b) {
+  try {
+    return dedupeKey(a) === dedupeKey(b);
+  } catch {
+    return a === b;
+  }
+}
+function severityOf(impact) {
+  switch (impact) {
+    case "critical":
+    case "serious":
+      return "error";
+    case "moderate":
+      return "warning";
+    default:
+      return "notice";
+  }
+}
+function impactOf(impact) {
+  return impact != null && isAxeImpact(impact) ? impact : "minor";
+}
+function toViolation(result) {
+  return {
+    id: result.id,
+    severity: severityOf(result.impact),
+    impact: impactOf(result.impact),
+    help: result.help,
+    helpUrl: result.helpUrl,
+    tags: result.tags,
+    nodes: result.nodes.map(toNode)
+  };
+}
+function toNode(node) {
+  return {
+    // A shadow-DOM target is a nested list of selectors; flatten it the same way.
+    target: node.target.map((t) => Array.isArray(t) ? t.join(" ") : t).join(" "),
+    html: node.html,
+    summary: node.failureSummary ?? ""
+  };
+}
+function reason(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.split("\n")[0]?.trim() ?? message;
+}
+
+// src/a11y/core/config.ts
+var SECTION = "a11y";
+var CONFIG_KEYS = ["urls", "crawl", "maxPages", "tags", "severity", "timeout", "exclude"];
+var CONFIG_FILE = {
+  section: SECTION,
+  // The a11y tool never had a pre-family file of its own.
+  legacyNames: [],
+  toError: (message) => new A11yError(message)
+};
+async function loadA11yConfig(cwd, explicitPath) {
+  const file = explicitPath === void 0 ? await findConfigFile(cwd, CONFIG_FILE) : await readConfigFile(explicitPath, cwd, CONFIG_FILE);
+  if (file === null) return { config: {}, source: null, collections: [] };
+  return {
+    config: parseA11yConfig(file.value, file.source),
+    source: file.source,
+    collections: file.collections
+  };
+}
+function parseA11yConfig(value, source) {
+  if (value == null) return {};
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new A11yError(`${source}: \`${SECTION}:\` must be a mapping.`);
+  }
+  const obj = value;
+  for (const key of Object.keys(obj)) {
+    if (!CONFIG_KEYS.includes(key)) {
+      throw new A11yError(
+        `${source}: \`${SECTION}:\` has unknown key "${key}". Supported keys: ${CONFIG_KEYS.join(", ")}.`
+      );
+    }
+  }
+  const config = {};
+  if (obj.urls !== void 0) config.urls = asUrls(obj.urls, source);
+  if (obj.crawl !== void 0) config.crawl = asBoolean(obj.crawl, "crawl", source);
+  if (obj.maxPages !== void 0) {
+    config.maxPages = asPositiveInteger(obj.maxPages, "maxPages", source);
+  }
+  if (obj.tags !== void 0) config.tags = asStringList(obj.tags, "tags", source);
+  if (obj.severity !== void 0) config.severity = asSeverity(obj.severity, source);
+  if (obj.timeout !== void 0) {
+    config.timeout = asPositiveInteger(obj.timeout, "timeout", source);
+  }
+  if (obj.exclude !== void 0) config.exclude = asExcludes(obj.exclude, source);
+  return config;
+}
+function excludeEntryLabel(source, index) {
+  return `${source}: "${SECTION}.exclude[${String(index)}]"`;
+}
+function asExcludes(value, source) {
+  const globs = asStringList(value, "exclude", source);
+  globs.forEach((glob, i) => {
+    const at = excludeEntryLabel(source, i);
+    if (glob === "") throw new A11yError(`${at} must be a non-empty string.`);
+    if (!isUrlPathGlob(glob)) throw new A11yError(`${at} ${MUST_START_WITH_SLASH}`);
+  });
+  return globs;
+}
+function asStringList(value, field, source) {
+  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+    throw new A11yError(`${source}: "${SECTION}.${field}" must be a list of strings.`);
+  }
+  return value;
+}
+function asUrls(value, source) {
+  const urls = asStringList(value, "urls", source);
+  urls.forEach((url, i) => {
+    if (!isHttpUrl(url)) {
+      throw new A11yError(
+        `${source}: "${SECTION}.urls[${i}]" must be an http(s) URL, got "${url}".`
+      );
+    }
+  });
+  return urls;
+}
+function asBoolean(value, field, source) {
+  if (typeof value !== "boolean") {
+    throw new A11yError(`${source}: "${SECTION}.${field}" must be a boolean.`);
+  }
+  return value;
+}
+function asPositiveInteger(value, field, source) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new A11yError(`${source}: "${SECTION}.${field}" must be an integer >= 1.`);
+  }
+  return value;
+}
+function asSeverity(value, source) {
+  if (typeof value !== "string" || !isSeverity(value)) {
+    throw new A11yError(
+      `${source}: "${SECTION}.severity" must be one of ${SEVERITIES.join(", ")}.`
+    );
+  }
+  return value;
+}
+
+// src/a11y/reporters/github.ts
+function annotationLevel(severity) {
+  return severity;
+}
+function renderGithub(run) {
+  const lines = [];
+  for (const page of run.results) {
+    if (page.error !== void 0) {
+      lines.push(
+        `::error title=a11y/load::${escapeWorkflowCommandMessage(`${page.url}: ${page.error}`)}`
+      );
+      continue;
+    }
+    for (const v of page.violations) {
+      const n = v.nodes.length;
+      const title = escapeWorkflowCommandProperty(`a11y/${v.id}`);
+      const msg = escapeWorkflowCommandMessage(
+        `${v.help} \u2014 ${n} node${n === 1 ? "" : "s"} on ${page.url} (${v.helpUrl})`
+      );
+      lines.push(`::${annotationLevel(v.severity)} title=${title}::${msg}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/a11y/reporters/json.ts
+function renderJson(run) {
+  return JSON.stringify(run, null, 2);
+}
+
+// src/a11y/reporters/pretty.ts
+var MAX_NODES = 3;
+function renderPretty(run, opts) {
+  const c = palette(opts.color);
+  const { summary } = run;
+  const lines = [];
+  lines.push(`Checked ${summary.checked} of ${summary.discovered} pages (${where(run, c)})`);
+  for (const page of run.results) {
+    if (page.error !== void 0) {
+      lines.push(`${c.red("\u2717")} ${c.cyan(page.url)}  could not load: ${page.error}`);
+      continue;
+    }
+    if (page.violations.length === 0) {
+      if (!opts.quiet) lines.push(`${c.green("\u2713")} ${c.cyan(page.url)}  score ${scoreText(page)}`);
+      continue;
+    }
+    lines.push(
+      `${c.red("\u2717")} ${c.cyan(page.url)}  score ${scoreText(page)}  ${severityCounts(page.violations, c)}`
+    );
+    for (const v of page.violations) lines.push(...violationLines(v, c));
+  }
+  if (!opts.quiet) {
+    for (const r of run.redirects) {
+      lines.push(`${c.dim("\u21AA")} ${c.cyan(r.url)}  redirects to ${c.cyan(r.to)}`);
+    }
+  }
+  const failed = summary.failed;
+  const footer = `${summary.violations} violation${summary.violations === 1 ? "" : "s"} on ${failed} of ${summary.checked} pages` + (summary.skipped > 0 ? `; ${summary.skipped} skipped (--max-pages)` : "") + (summary.duplicates > 0 ? `; ${summary.duplicates} duplicate${summary.duplicates === 1 ? "" : "s"} dropped` : "") + (summary.redirects > 0 ? `; ${summary.redirects} redirect${summary.redirects === 1 ? "" : "s"}` : "") + (summary.excluded > 0 ? `; ${summary.excluded} excluded` : "");
+  lines.push("");
+  lines.push(failed > 0 ? c.red(footer) : c.green(footer));
+  return lines.join("\n");
+}
+function where(run, c) {
+  const { summary } = run;
+  if (!summary.crawl) return "no crawl";
+  if (summary.sitemap === null) return "no sitemap; followed links";
+  const found = `sitemap: ${c.cyan(summary.sitemap)}`;
+  const n = summary.sitemapPages;
+  if (n === 0) return `${found}, 0 pages; followed links`;
+  if (n >= summary.discovered) return found;
+  return `${found}, ${n} page${n === 1 ? "" : "s"}; followed links for the rest`;
+}
+function scoreText(page) {
+  return page.score === null ? "n/a" : String(page.score);
+}
+function severityCounts(violations, c) {
+  const counts = { notice: 0, warning: 0, error: 0 };
+  for (const v of violations) counts[v.severity] += 1;
+  return [...SEVERITIES].reverse().filter((severity) => counts[severity] > 0).map((severity) => {
+    const n = counts[severity];
+    return paintSeverity(`${n} ${severity}${n === 1 ? "" : "s"}`, severity, c);
+  }).join(", ");
+}
+function violationLines(v, c) {
+  const n = v.nodes.length;
+  const lines = [
+    `    ${paintSeverity(v.severity, v.severity, c)}  ${v.id} ${c.dim(`(axe: ${v.impact})`)}  ${n} node${n === 1 ? "" : "s"}  ${v.help}  ${c.dim(v.helpUrl)}`
+  ];
+  for (const node of v.nodes.slice(0, MAX_NODES)) {
+    lines.push(`      ${node.target}  \u2192 ${oneLine(node.summary)}`);
+  }
+  if (n > MAX_NODES) lines.push(c.dim(`      (+${n - MAX_NODES} more)`));
+  return lines;
+}
+function oneLine(summary) {
+  const [head, ...rest] = summary.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (head === void 0) return "";
+  return rest.length === 0 ? head : `${head} ${rest.join("; ")}`;
+}
+function paintSeverity(text, severity, c) {
+  switch (severity) {
+    case "notice":
+      return c.dim(text);
+    case "warning":
+      return c.yellow(text);
+    case "error":
+      return c.red(text);
+  }
+}
+
+// src/a11y/reporters/index.ts
+var A11Y_FORMATS = ["pretty", "json", "github"];
+var A11Y_FORMAT_LIST = A11Y_FORMATS.join(" | ");
+function isA11yFormat(value) {
+  return A11Y_FORMATS.includes(value);
+}
+function render(format, run, opts) {
+  switch (format) {
+    case "pretty":
+      return renderPretty(run, opts);
+    case "json":
+      return renderJson(run);
+    case "github":
+      return renderGithub(run);
+    default: {
+      const unreachable = format;
+      throw new A11yError(
+        `Unknown report format ${JSON.stringify(unreachable)}. Use ${A11Y_FORMAT_LIST}.`
+      );
+    }
+  }
+}
+
+// src/a11y/reporters/progress.ts
+var CLEAR_LINE = "\r\x1B[2K";
+var DEFAULT_COLUMNS = 80;
+function createProgressReporter(opts) {
+  return opts.tty ? terminalReporter(opts) : plainReporter(opts.stream);
+}
+function plural(n, noun) {
+  return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+function counter(index, queued) {
+  return `[${index}/${queued}]`;
+}
+function terminalReporter(opts) {
+  const { stream } = opts;
+  const c = palette(opts.color);
+  let queued = 0;
+  const show = (text) => {
+    stream.write(`${CLEAR_LINE}${text}`);
+  };
+  const showUrl = (prefix, url, suffix = "") => {
+    const columns = stream.columns ?? DEFAULT_COLUMNS;
+    const fitted = truncateMiddle(url, columns - visibleLength(prefix) - suffix.length);
+    show(`${prefix}${c.cyan(fitted)}${suffix}`);
+  };
+  return (event) => {
+    switch (event.kind) {
+      case "browser":
+        show("Starting browser\u2026");
+        return;
+      case "sitemap":
+        if (event.source === null) show("No sitemap; following links");
+        else showUrl("Sitemap: ", event.source, ` (${plural(event.urls, "page")})`);
+        return;
+      case "excluded":
+        show(`Excluded ${plural(event.urls, "page")} (${plural(event.patterns, "pattern")})`);
+        return;
+      case "page":
+        queued = event.queued;
+        showUrl(`${c.dim(counter(event.index, queued))} `, event.url);
+        return;
+      case "checked":
+        showUrl(`${c.dim(counter(event.index, queued))} ${outcome(event, c)}`, event.url);
+        return;
+      case "redirected":
+        showUrl(`${c.dim(counter(event.index, queued))} ${c.dim("\u21AA")} redirects to `, event.to);
+        return;
+      case "done":
+        stream.write(CLEAR_LINE);
+        return;
+    }
+  };
+}
+function outcome(event, c) {
+  if (event.error !== void 0) return `${c.red("\u2717")} could not load: ${event.error}  `;
+  if (event.violations === 0) return `${c.green("\u2713")} `;
+  return `${c.red("\u2717")} ${plural(event.violations, "violation")}  `;
+}
+function plainReporter(stream) {
+  let queued = 0;
+  const say = (text) => {
+    stream.write(`${programName()}: ${text}
+`);
+  };
+  return (event) => {
+    switch (event.kind) {
+      case "browser":
+        say("starting browser");
+        return;
+      case "sitemap":
+        if (event.source === null) say("no sitemap; following links");
+        else say(`sitemap ${event.source} (${plural(event.urls, "page")})`);
+        return;
+      case "excluded":
+        say(`excluded ${plural(event.urls, "page")} (${plural(event.patterns, "pattern")})`);
+        return;
+      case "page":
+        queued = event.queued;
+        say(`${counter(event.index, queued)} ${event.url}`);
+        return;
+      case "checked": {
+        const head = counter(event.index, queued);
+        if (event.error !== void 0) say(`${head} could not load: ${event.error}`);
+        else if (event.violations === 0) say(`${head} \u2713`);
+        else say(`${head} \u2717 ${plural(event.violations, "violation")}`);
+        return;
+      }
+      case "redirected":
+        say(`${counter(event.index, queued)} \u21AA redirects to ${event.to}`);
+        return;
+      case "done":
+        say(`checked ${plural(event.checked, "page")}, ${event.skipped} skipped`);
+        return;
+    }
+  };
+}
+function visibleLength(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function truncateMiddle(text, room) {
+  const max = Math.max(room, 8);
+  if (text.length <= max) return text;
+  const head = Math.ceil((max - 1) / 2);
+  const tail = max - 1 - head;
+  return `${text.slice(0, head)}\u2026${text.slice(text.length - tail)}`;
+}
+
+// src/a11y/cli.ts
+function collect(value, prev) {
+  return prev.concat([value]);
+}
+function splitList(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function resolveColor(program, stream) {
+  const noColor = program.opts().color === false;
+  return shouldColor({ noColor, isTTY: stream.isTTY });
+}
+function resolveProgress(program, flag) {
+  const tty = process.stderr.isTTY ?? false;
+  const silent = { listener: void 0, clear: () => void 0 };
+  if (!(flag ?? tty)) return silent;
+  const listener = createProgressReporter({
+    stream: process.stderr,
+    color: resolveColor(program, process.stderr),
+    tty
+  });
+  if (!tty) return { listener, clear: silent.clear };
+  return {
+    listener,
+    clear: () => {
+      process.stderr.write(CLEAR_LINE);
+    }
+  };
+}
+function positiveInteger(value, flag) {
+  if (!/^[1-9]\d*$/.test(value)) {
+    throw new A11yError(`${flag} must be an integer >= 1.`);
+  }
+  return Number(value);
+}
+function parseMaxPages(value) {
+  if (value === false) return "uncapped";
+  if (value === void 0) return void 0;
+  return positiveInteger(value, "--max-pages");
+}
+function resolveMaxPages(flag, configured) {
+  if (flag === "uncapped") return void 0;
+  return flag ?? configured;
+}
+function resolveCrawl(flag, configured) {
+  return flag ?? configured ?? CHECK_DEFAULTS.crawl;
+}
+function assertExcludeGlobs(globs) {
+  return globs.map((glob) => {
+    if (!isUrlPathGlob(glob)) {
+      throw new A11yError(`--exclude "${glob}" ${MUST_START_WITH_SLASH}`);
+    }
+    return { glob, source: `--exclude "${glob}"` };
+  });
+}
+function configExcludeGlobs(globs, source) {
+  const file = source ?? FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml";
+  return globs.map((glob, i) => ({ glob, source: excludeEntryLabel(file, i) }));
+}
+function assertSeverity(value) {
+  if (!isSeverity(value)) {
+    throw new A11yError(`Unknown --severity "${value}". Use ${SEVERITY_LIST}.`);
+  }
+  return value;
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("a11y").description("Crawl a site and check every page for accessibility violations with axe-core").version(package_default.version, "-V, --version").option("--no-color", "disable colored output").showHelpAfterError("(add --help for usage)").exitOverride();
+  program.command("check").description("Crawl from the given URLs and check every page with axe-core").argument(
+    "[urls...]",
+    "http(s) seed URLs; falls back to a collection's url: or a11y.urls in manni.config.yaml"
+  ).option("-f, --format <format>", `output: ${A11Y_FORMAT_LIST}`, "pretty").option("--crawl", "crawl from the given URLs: sitemap and link following (default)").option("--no-crawl", "check exactly the given URLs: no sitemap, no link following").option(
+    "--max-pages <n>",
+    "cap on pages checked; the rest are reported as skipped (default: no cap)"
+  ).option("--no-max-pages", "check every page found, ignoring a configured maxPages").option(
+    "--exclude <glob>",
+    "URL path glob to keep out of the crawl; repeatable",
+    collect,
+    []
+  ).option("--tags <list>", "comma-separated axe tags to restrict the rules to").option(
+    "--severity <level>",
+    `minimum severity reported: ${SEVERITY_LIST}`,
+    CHECK_DEFAULTS.severity
+  ).option(
+    "--timeout <ms>",
+    "per-page navigation timeout in milliseconds",
+    String(CHECK_DEFAULTS.timeout)
+  ).option("-q, --quiet", "in pretty output, hide pages with no violations").option("--progress", "report progress on stderr (default: only on a terminal)").option("--no-progress", "never report progress").option(
+    "--collection <name>",
+    "configured collection to run over; repeatable",
+    collect,
+    []
+  ).option("-c, --config <path>", "path to a manni config file").option("--no-config", "ignore any discovered config file").action(async (urls, options, command) => {
+    let clearProgress = () => void 0;
+    try {
+      const typed = (name) => command.getOptionValueSource(name) === "cli";
+      const format = options.format;
+      if (!isA11yFormat(format)) {
+        throw new A11yError(`Unknown --format "${format}". Use ${A11Y_FORMAT_LIST}.`);
+      }
+      const severity = assertSeverity(options.severity);
+      const maxPages = parseMaxPages(options.maxPages);
+      const timeout = positiveInteger(options.timeout, "--timeout");
+      const exclude = assertExcludeGlobs(options.exclude);
+      const loaded = options.config === false ? { config: {}, source: null, collections: [] } : await loadA11yConfig(process.cwd(), options.config);
+      const cfg = loaded.config;
+      const seeds = resolveSeeds({
+        urls,
+        collections: options.collection,
+        ...cfg.urls === void 0 ? {} : { configUrls: cfg.urls },
+        declared: loaded.collections,
+        source: loaded.source
+      });
+      const parent = command.parent ?? command;
+      const progress = resolveProgress(parent, options.progress);
+      clearProgress = progress.clear;
+      const run = await runCheck(
+        {
+          urls: seeds,
+          crawl: resolveCrawl(options.crawl, cfg.crawl),
+          // Typed flag > config key > no cap. There is no default to fall
+          // to, and `--no-max-pages` is the typed way to ask for none.
+          maxPages: resolveMaxPages(maxPages, cfg.maxPages),
+          tags: options.tags !== void 0 ? splitList(options.tags) : cfg.tags ?? CHECK_DEFAULTS.tags,
+          // A typed flag replaces the config list entirely; the two do not
+          // merge. Merging would only ever let a run exclude *more* than
+          // the repository's default, so checking one excluded section on
+          // purpose would need --no-config, which also drops collections:.
+          exclude: typed("exclude") ? exclude : configExcludeGlobs(cfg.exclude ?? [], loaded.source),
+          severity: typed("severity") ? severity : cfg.severity ?? CHECK_DEFAULTS.severity,
+          timeout: typed("timeout") ? timeout : cfg.timeout ?? CHECK_DEFAULTS.timeout
+        },
+        { analyzer: createPlaywrightAnalyzer(), onProgress: progress.listener }
+      );
+      const color = resolveColor(parent, process.stdout);
+      const text = render(format, run, { color, quiet: Boolean(options.quiet) });
+      if (text.length > 0 || format !== "github") {
+        process.stdout.write(`${text}
+`);
+      }
+      process.exitCode = run.summary.failed > 0 ? 1 : 0;
+    } catch (err) {
+      clearProgress();
+      fail(err);
+    }
+  });
+  return program;
+}
+export {
+  assertExcludeGlobs,
+  buildProgram,
+  configExcludeGlobs,
+  parseMaxPages,
+  positiveInteger,
+  resolveCrawl,
+  resolveMaxPages
+};
+//# sourceMappingURL=cli-6HIDIFVT.js.map