@seostudio/audit-engine 0.0.0-stage → 0.1.0

package/dist/chunk-7SGWGESF.js

@@ -0,0 +1,1753 @@
+import { seoResourceCheckLimits, seoCrawlerLimits, onSiteOrBelow, bareHostOfKey, hostOfKey } from './chunk-6QPF6O7D.js';
+
+// src/urls.ts
+var TRACKING_PARAMS = /* @__PURE__ */ new Set([
+  "fbclid",
+  "gclid",
+  "gbraid",
+  "wbraid",
+  "dclid",
+  "msclkid",
+  "yclid",
+  "twclid",
+  "ttclid",
+  "li_fat_id",
+  "mc_cid",
+  "mc_eid",
+  "_ga",
+  "_gl",
+  "_hsenc",
+  "_hsmi",
+  "__hstc",
+  "__hssc",
+  "__hsfp",
+  "igshid",
+  "srsltid"
+]);
+function isTracking(name) {
+  const lower = name.toLowerCase();
+  return lower.startsWith("utm_") || TRACKING_PARAMS.has(lower);
+}
+function canonicalPart(part, encode) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(part);
+  } catch {
+    return part;
+  }
+  return encode(decoded.normalize("NFC"));
+}
+function encodePath(path) {
+  return path.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+function normalizePageUrl(url, host) {
+  const trimmed = url.trim();
+  if (trimmed === "") return null;
+  let parsed;
+  try {
+    if (/^https?:\/\//i.test(trimmed)) {
+      parsed = new URL(trimmed);
+    } else if (host !== void 0 && host !== null && host.trim() !== "") {
+      const path2 = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+      parsed = new URL(`https://${host.trim()}${path2}`);
+    } else {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+  const hostname = parsed.hostname.toLowerCase().replace(/\.$/, "");
+  if (hostname === "") return null;
+  const port = parsed.port === "" ? "" : `:${parsed.port}`;
+  const rawPath = canonicalPart(parsed.pathname, encodePath).replace(/\/{2,}/g, "/");
+  const path = rawPath.length > 1 ? rawPath.replace(/\/+$/, "") : "/";
+  const params = [...parsed.searchParams.entries()].filter(([name]) => !isTracking(name)).map(([name, value]) => [name.normalize("NFC"), value.normalize("NFC")]).sort(
+    ([leftName, leftValue], [rightName, rightValue]) => leftName === rightName ? leftValue.localeCompare(rightValue) : leftName.localeCompare(rightName)
+  );
+  const query = params.length === 0 ? "" : `?${params.map(([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(value)}`).join("&")}`;
+  return `${hostname}${port}${path === "/" ? "/" : path}${query}`;
+}
+function canonicalMismatch(google, declared) {
+  if (google === null || declared === null) return false;
+  const left = normalizePageUrl(google) ?? google;
+  const right = normalizePageUrl(declared) ?? declared;
+  return left !== right;
+}
+
+// src/robots.ts
+var SEO_ROBOTS_MAX_BYTES = 500 * 1024;
+function parseRobots(text) {
+  const groups = [];
+  const sitemaps = [];
+  if (text === null) return { groups, sitemaps };
+  let current = null;
+  let lastWasAgent = false;
+  for (const rawLine of text.slice(0, SEO_ROBOTS_MAX_BYTES).split(/\r?\n/)) {
+    const hash = rawLine.indexOf("#");
+    const line = (hash === -1 ? rawLine : rawLine.slice(0, hash)).trim();
+    if (line === "") continue;
+    const colon = line.indexOf(":");
+    if (colon === -1) continue;
+    const field = line.slice(0, colon).trim().toLowerCase();
+    const value = line.slice(colon + 1).trim();
+    if (field === "sitemap") {
+      if (value !== "") sitemaps.push(value);
+      continue;
+    }
+    if (field === "user-agent") {
+      if (current === null || !lastWasAgent) {
+        current = { agents: [], rules: [], crawlDelaySeconds: null };
+        groups.push(current);
+      }
+      current.agents.push(value);
+      lastWasAgent = true;
+      continue;
+    }
+    lastWasAgent = false;
+    if (current === null) continue;
+    if (field === "allow" || field === "disallow") {
+      if (value === "" && field === "disallow") continue;
+      current.rules.push({ allow: field === "allow", path: value });
+    } else if (field === "crawl-delay") {
+      const seconds = Number.parseFloat(value);
+      if (Number.isFinite(seconds) && seconds >= 0) current.crawlDelaySeconds = seconds;
+    }
+  }
+  return { groups, sitemaps };
+}
+function productToken(value) {
+  return (/^[a-z_-]+/i.exec(value.trim())?.[0] ?? "").toLowerCase();
+}
+function compileRobots(robots, agent) {
+  const token = productToken(agent);
+  const names = (name) => {
+    const named2 = productToken(name);
+    return named2 !== "" && named2 === token;
+  };
+  const named = robots.groups.filter((group) => group.agents.some(names));
+  const chosen = named.length > 0 ? named : robots.groups.filter((group) => group.agents.includes("*"));
+  const delays = chosen.map((group) => group.crawlDelaySeconds).filter((delay) => delay !== null);
+  return {
+    rules: chosen.flatMap((group) => {
+      const userAgent = group.agents.find(names) ?? "*";
+      return group.rules.map((rule2) => {
+        const anchored = rule2.path.endsWith("$");
+        return {
+          allow: rule2.allow,
+          length: rule2.path.length,
+          parts: (anchored ? rule2.path.slice(0, -1) : rule2.path).split("*"),
+          anchored,
+          line: `${rule2.allow ? "Allow" : "Disallow"}: ${rule2.path}`,
+          userAgent
+        };
+      });
+    }),
+    crawlDelayMs: delays.length > 0 ? Math.round(Math.max(...delays) * 1e3) : null,
+    sitemaps: robots.sitemaps
+  };
+}
+function ruleMatches(rule2, target) {
+  const { parts, anchored } = rule2;
+  const first = parts[0] ?? "";
+  if (parts.length === 1) return anchored ? target === first : target.startsWith(first);
+  if (!target.startsWith(first)) return false;
+  let position = first.length;
+  for (let index = 1; index < parts.length - 1; index += 1) {
+    const part = parts[index] ?? "";
+    if (part === "") continue;
+    const found = target.indexOf(part, position);
+    if (found === -1) return false;
+    position = found + part.length;
+  }
+  const last = parts[parts.length - 1] ?? "";
+  if (anchored) return target.length - last.length >= position && target.endsWith(last);
+  return last === "" || target.includes(last, position);
+}
+function compileRobotsPattern(pattern) {
+  const anchored = pattern.endsWith("$");
+  return { parts: (anchored ? pattern.slice(0, -1) : pattern).split("*"), anchored };
+}
+function robotsPatternMatches(pattern, target) {
+  return ruleMatches(pattern, target);
+}
+function robotsDecision(robots, url) {
+  let target;
+  try {
+    const parsed = new URL(url);
+    target = `${parsed.pathname}${parsed.search}`;
+  } catch {
+    return { allowed: false, rule: null };
+  }
+  if (target === "/robots.txt") return { allowed: true, rule: null };
+  let best = null;
+  for (const rule2 of robots.rules) {
+    if (!ruleMatches(rule2, target)) continue;
+    if (best === null || rule2.length > best.length || rule2.length === best.length && rule2.allow) {
+      best = rule2;
+    }
+  }
+  return {
+    allowed: best === null || best.allow,
+    rule: best === null ? null : { line: best.line, userAgent: best.userAgent }
+  };
+}
+function robotsAllows(robots, url) {
+  return robotsDecision(robots, url).allowed;
+}
+function directivesNoindex(...directives) {
+  return directives.some(
+    (value) => value !== null && value !== void 0 && /\b(?:noindex|none)\b/i.test(value)
+  );
+}
+function directivesNofollow(...directives) {
+  return directives.some(
+    (value) => value !== null && value !== void 0 && /\b(?:nofollow|none)\b/i.test(value)
+  );
+}
+var ROBOTS_UNREACHABLE = /* @__PURE__ */ new Set([
+  "server_error",
+  "timeout",
+  "redirect_loop"
+]);
+function isRobotsUnreachable(outcome) {
+  return ROBOTS_UNREACHABLE.has(outcome);
+}
+
+// src/reading-limits.ts
+var SEO_READING_LIMITS = {
+  /** Characters of a page's main text. */
+  mainTextChars: 2e6,
+  /** Links of one page. */
+  links: 1e4,
+  /** Characters of a URL, an anchor or a header value. */
+  textChars: 4e3,
+  /** Entries of a list the audit only counts or samples (mixed content, unsized images, canonicals). */
+  listItems: 500,
+  /** JSON-LD blocks, and their characters together. */
+  jsonLdBlocks: 200,
+  jsonLdChars: 1e6,
+  /** hreflang alternates. */
+  hreflang: 1e3,
+  /** Schema types. */
+  schemaTypes: 200,
+  /** Hops of a redirect chain. */
+  chainHops: 20,
+  /** Readings in one batch. */
+  batchPages: 50,
+  /** Sitemap URLs in a plan reading, the characters of each, and sitemap files. */
+  sitemapUrls: seoCrawlerLimits.maxSitemapUrls,
+  sitemapUrlChars: 2048,
+  sitemapFiles: seoCrawlerLimits.maxSitemapFiles,
+  /** Characters of a robots.txt. */
+  robotsChars: SEO_ROBOTS_MAX_BYTES,
+  /** Console lines of a render, the characters of each, and the failed resources it names. */
+  renderConsoleLines: 20,
+  renderConsoleChars: 300,
+  renderFailures: 50,
+  /** Resource check readings in one upload: one hand-out's worth. */
+  resourceReadings: seoResourceCheckLimits.checksPerStep
+};
+var SEO_MARKUP_LIMITS = {
+  /** Entries of a list of tags of one kind (titles, canonicals, viewports, ...). */
+  values: 10,
+  /** Characters of one value kept. */
+  valueChars: 500,
+  /** Directives of one robots group. */
+  robotsTokens: 50,
+  /** Examples of a counted kind, and the characters of each. */
+  examples: 5,
+  exampleChars: 300,
+  /** Images described one by one. */
+  images: 40,
+  /** Element ids kept for bookmarks, and the characters of each. */
+  ids: 300,
+  idChars: 100,
+  /** Links to another page's fragment. */
+  externalBookmarks: 20,
+  /** Forms described one by one. */
+  forms: 10,
+  /** `rel="next"` and `rel="prev"` targets of each. */
+  pagination: 5,
+  /** Analytics ids. */
+  analyticsIds: 10,
+  /** Subresource URLs handed to the resource checks, and the characters of each. */
+  resources: 300,
+  resourceChars: 2e3,
+  /** Microdata and RDFa items kept, and their JSON's characters together (the JSON-LD budget's size). */
+  structuredItems: 30,
+  structuredChars: 16e3,
+  /** Prices and ratings the structured data states. */
+  markedValues: 20,
+  /** Elements the microdata and RDFa reads visit, and how deep an item may nest in another. */
+  structuredElements: 1e5,
+  structuredDepth: 32,
+  /** Characters of one microdata or RDFa text value, and of every value one read takes together. */
+  structuredValueChars: 1e3,
+  structuredReadChars: 2e5,
+  /** Characters of visible text searched for the marked-up prices and ratings. */
+  shownTextChars: 1e6,
+  /** JSON-LD blocks read for prices and ratings, the characters of one block, and of all together. */
+  jsonBlocks: 200,
+  jsonBlockChars: 1e6,
+  jsonChars: 1e6,
+  /** How deep a JSON-LD block may nest, the values one page's walks visit, and the `@id`s indexed. */
+  jsonDepth: 64,
+  jsonNodes: 1e5,
+  jsonIds: 1e3
+};
+var SEO_CUSTOM_CHECK_LIMITS = {
+  /** Patterns per project. */
+  checks: 10,
+  /** Characters of a pattern id, a pattern, a name and an attribute. */
+  idChars: 40,
+  patternChars: 300,
+  nameChars: 80,
+  attributeChars: 60,
+  /** Characters of a page's HTML searched. */
+  htmlChars: 2e6,
+  /**
+   * The work one page's patterns may do together, shared out evenly between them: a regular
+   * expression spends its size for every character it reads, a selector one unit per step through the
+   * page's elements. A pattern that spends its share yields no result on that page.
+   */
+  pageWork: 3e7,
+  /** The largest regular expression a pattern may compile to (RE2 program instructions). */
+  regexProgram: 500,
+  /** Matches counted per pattern and page. */
+  matches: 1e3,
+  /** Values kept per pattern and page, and the characters of each. */
+  values: 10,
+  valueChars: 300
+};
+var SEO_CRAWL_OPTION_LIMITS = {
+  /** Characters of a member's own User-Agent. */
+  userAgentChars: 300,
+  /** The deepest link depth a member may set. */
+  maxDepth: 100,
+  /** The slowest and the fastest pace of a crawl on a member's computer, in requests per second. */
+  minRequestsPerSecond: 0.2,
+  maxRequestsPerSecond: 5,
+  /** Snippets per project, the characters of each, and of a snippet's or a prompt's name. */
+  scripts: 5,
+  scriptChars: 4e3,
+  nameChars: 80,
+  /** The characters of a snippet's value kept per page. */
+  scriptValueChars: 300,
+  /** AI prompts per project, and the characters of each. */
+  prompts: 3,
+  promptChars: 1e3
+};
+var SEO_CRAWL_USER_AGENT_PRESETS = [
+  "own",
+  "googlebot_smartphone",
+  "googlebot_desktop",
+  "bingbot",
+  "custom"
+];
+var SEO_CRAWL_ROBOTS_GROUPS = [
+  "own",
+  "googlebot",
+  "bingbot"
+];
+var SEO_CUSTOM_CHECK_MODES = [
+  "contains",
+  "absent",
+  "extract"
+];
+var SEO_CUSTOM_CHECK_MATCHES = [
+  "text",
+  "regex",
+  "css"
+];
+var SEO_GRAMMAR_LIMITS = {
+  /** Characters of text read. */
+  textChars: 2e4,
+  /** Problems kept. */
+  issues: 20,
+  /** Characters of a problem's kind, text and suggestion. */
+  textKept: 120
+};
+
+// src/bytes.ts
+async function readStreamCapped(stream, maxBytes) {
+  if (stream === null) return { body: new Uint8Array(0), truncated: false, sizeBytes: 0 };
+  const reader = stream.getReader();
+  const chunks = [];
+  let size = 0;
+  let truncated = false;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const room = maxBytes - size;
+    if (value.byteLength > room) {
+      if (room > 0) chunks.push(value.subarray(0, room));
+      size += value.byteLength;
+      truncated = true;
+      await reader.cancel().catch(() => void 0);
+      break;
+    }
+    chunks.push(value);
+    size += value.byteLength;
+  }
+  const body = new Uint8Array(Math.min(size, maxBytes));
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { body, truncated, sizeBytes: size };
+}
+async function drainStreamCapped(stream, maxBytes, sink) {
+  if (stream === null) return { truncated: false, sizeBytes: 0 };
+  const reader = stream.getReader();
+  let size = 0;
+  for (; ; ) {
+    let next;
+    try {
+      next = await reader.read();
+    } catch (error) {
+      if (size === 0) throw error;
+      return { truncated: true, sizeBytes: size };
+    }
+    const { done, value } = next;
+    if (done) return { truncated: false, sizeBytes: size };
+    const room = maxBytes - size;
+    size += value.byteLength;
+    const over = value.byteLength > room;
+    const more = await sink(over ? value.subarray(0, Math.max(0, room)) : value);
+    if (over || !more) {
+      await reader.cancel().catch(() => void 0);
+      return { truncated: over, sizeBytes: size };
+    }
+  }
+}
+function bytesStream(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return new Blob([copy]).stream();
+}
+async function gunzipCapped(bytes, maxBytes) {
+  return readStreamCapped(
+    bytesStream(bytes).pipeThrough(new DecompressionStream("gzip")),
+    maxBytes
+  );
+}
+
+// src/a11y-rules.generated.ts
+var SEO_A11Y_RULES = {
+  a11y_accesskeys: { axe: "accesskeys", impact: "serious", seo: false },
+  a11y_area_alt: { axe: "area-alt", impact: "critical", seo: false },
+  a11y_aria_allowed_attr: { axe: "aria-allowed-attr", impact: "critical", seo: false },
+  a11y_aria_allowed_role: { axe: "aria-allowed-role", impact: "minor", seo: false },
+  a11y_aria_braille_equivalent: { axe: "aria-braille-equivalent", impact: "serious", seo: false },
+  a11y_aria_command_name: { axe: "aria-command-name", impact: "serious", seo: true },
+  a11y_aria_conditional_attr: { axe: "aria-conditional-attr", impact: "serious", seo: false },
+  a11y_aria_deprecated_role: { axe: "aria-deprecated-role", impact: "minor", seo: false },
+  a11y_aria_dialog_name: { axe: "aria-dialog-name", impact: "serious", seo: true },
+  a11y_aria_hidden_body: { axe: "aria-hidden-body", impact: "critical", seo: false },
+  a11y_aria_hidden_focus: { axe: "aria-hidden-focus", impact: "serious", seo: false },
+  a11y_aria_input_field_name: { axe: "aria-input-field-name", impact: "serious", seo: true },
+  a11y_aria_meter_name: { axe: "aria-meter-name", impact: "serious", seo: true },
+  a11y_aria_progressbar_name: { axe: "aria-progressbar-name", impact: "serious", seo: true },
+  a11y_aria_prohibited_attr: { axe: "aria-prohibited-attr", impact: "serious", seo: false },
+  a11y_aria_required_attr: { axe: "aria-required-attr", impact: "critical", seo: false },
+  a11y_aria_required_children: { axe: "aria-required-children", impact: "critical", seo: false },
+  a11y_aria_required_parent: { axe: "aria-required-parent", impact: "critical", seo: false },
+  a11y_aria_roles: { axe: "aria-roles", impact: "critical", seo: false },
+  a11y_aria_tab_name: { axe: "aria-tab-name", impact: "serious", seo: true },
+  a11y_aria_text: { axe: "aria-text", impact: "serious", seo: false },
+  a11y_aria_toggle_field_name: { axe: "aria-toggle-field-name", impact: "serious", seo: true },
+  a11y_aria_tooltip_name: { axe: "aria-tooltip-name", impact: "serious", seo: true },
+  a11y_aria_treeitem_name: { axe: "aria-treeitem-name", impact: "serious", seo: true },
+  a11y_aria_valid_attr: { axe: "aria-valid-attr", impact: "critical", seo: false },
+  a11y_aria_valid_attr_value: { axe: "aria-valid-attr-value", impact: "critical", seo: false },
+  a11y_autocomplete_valid: { axe: "autocomplete-valid", impact: "serious", seo: false },
+  a11y_avoid_inline_spacing: { axe: "avoid-inline-spacing", impact: "serious", seo: false },
+  a11y_blink: { axe: "blink", impact: "serious", seo: false },
+  a11y_button_name: { axe: "button-name", impact: "critical", seo: true },
+  a11y_bypass: { axe: "bypass", impact: "serious", seo: false },
+  a11y_color_contrast: { axe: "color-contrast", impact: "serious", seo: false },
+  a11y_definition_list: { axe: "definition-list", impact: "serious", seo: false },
+  a11y_dlitem: { axe: "dlitem", impact: "serious", seo: false },
+  a11y_duplicate_id_aria: { axe: "duplicate-id-aria", impact: "critical", seo: true },
+  a11y_empty_heading: { axe: "empty-heading", impact: "minor", seo: true },
+  a11y_empty_table_header: { axe: "empty-table-header", impact: "minor", seo: false },
+  a11y_form_field_multiple_labels: {
+    axe: "form-field-multiple-labels",
+    impact: "moderate",
+    seo: false
+  },
+  a11y_frame_focusable_content: { axe: "frame-focusable-content", impact: "serious", seo: false },
+  a11y_frame_title: { axe: "frame-title", impact: "serious", seo: true },
+  a11y_frame_title_unique: { axe: "frame-title-unique", impact: "serious", seo: false },
+  a11y_html_xml_lang_mismatch: { axe: "html-xml-lang-mismatch", impact: "moderate", seo: false },
+  a11y_image_redundant_alt: { axe: "image-redundant-alt", impact: "minor", seo: false },
+  a11y_input_button_name: { axe: "input-button-name", impact: "critical", seo: true },
+  a11y_input_image_alt: { axe: "input-image-alt", impact: "critical", seo: true },
+  a11y_label: { axe: "label", impact: "critical", seo: true },
+  a11y_label_title_only: { axe: "label-title-only", impact: "serious", seo: false },
+  a11y_landmark_banner_is_top_level: {
+    axe: "landmark-banner-is-top-level",
+    impact: "moderate",
+    seo: false
+  },
+  a11y_landmark_contentinfo_is_top_level: {
+    axe: "landmark-contentinfo-is-top-level",
+    impact: "moderate",
+    seo: false
+  },
+  a11y_landmark_main_is_top_level: {
+    axe: "landmark-main-is-top-level",
+    impact: "moderate",
+    seo: false
+  },
+  a11y_landmark_no_duplicate_banner: {
+    axe: "landmark-no-duplicate-banner",
+    impact: "moderate",
+    seo: false
+  },
+  a11y_landmark_no_duplicate_contentinfo: {
+    axe: "landmark-no-duplicate-contentinfo",
+    impact: "moderate",
+    seo: false
+  },
+  a11y_landmark_no_duplicate_main: {
+    axe: "landmark-no-duplicate-main",
+    impact: "moderate",
+    seo: false
+  },
+  a11y_landmark_one_main: { axe: "landmark-one-main", impact: "moderate", seo: false },
+  a11y_landmark_unique: { axe: "landmark-unique", impact: "moderate", seo: false },
+  a11y_link_in_text_block: { axe: "link-in-text-block", impact: "serious", seo: false },
+  a11y_list: { axe: "list", impact: "serious", seo: false },
+  a11y_listitem: { axe: "listitem", impact: "serious", seo: false },
+  a11y_marquee: { axe: "marquee", impact: "serious", seo: false },
+  a11y_meta_viewport_large: { axe: "meta-viewport-large", impact: "minor", seo: false },
+  a11y_nested_interactive: { axe: "nested-interactive", impact: "serious", seo: false },
+  a11y_no_autoplay_audio: { axe: "no-autoplay-audio", impact: "moderate", seo: false },
+  a11y_object_alt: { axe: "object-alt", impact: "serious", seo: false },
+  a11y_presentation_role_conflict: {
+    axe: "presentation-role-conflict",
+    impact: "minor",
+    seo: false
+  },
+  a11y_region: { axe: "region", impact: "moderate", seo: false },
+  a11y_role_img_alt: { axe: "role-img-alt", impact: "serious", seo: true },
+  a11y_scope_attr_valid: { axe: "scope-attr-valid", impact: "moderate", seo: false },
+  a11y_scrollable_region_focusable: {
+    axe: "scrollable-region-focusable",
+    impact: "serious",
+    seo: false
+  },
+  a11y_select_name: { axe: "select-name", impact: "critical", seo: true },
+  a11y_server_side_image_map: { axe: "server-side-image-map", impact: "minor", seo: false },
+  a11y_skip_link: { axe: "skip-link", impact: "moderate", seo: false },
+  a11y_summary_name: { axe: "summary-name", impact: "serious", seo: true },
+  a11y_svg_img_alt: { axe: "svg-img-alt", impact: "serious", seo: true },
+  a11y_tabindex: { axe: "tabindex", impact: "serious", seo: false },
+  a11y_table_duplicate_name: { axe: "table-duplicate-name", impact: "minor", seo: false },
+  a11y_td_headers_attr: { axe: "td-headers-attr", impact: "serious", seo: false },
+  a11y_th_has_data_cells: { axe: "th-has-data-cells", impact: "serious", seo: false },
+  a11y_valid_lang: { axe: "valid-lang", impact: "serious", seo: true },
+  a11y_video_caption: { axe: "video-caption", impact: "critical", seo: false }
+};
+
+// src/catalog.ts
+function seoAuditByCategory(value) {
+  return {
+    indexing: value("indexing"),
+    redirects: value("redirects"),
+    links: value("links"),
+    content: value("content"),
+    metadata: value("metadata"),
+    structured_data: value("structured_data"),
+    international: value("international"),
+    performance: value("performance"),
+    mobile: value("mobile"),
+    accessibility: value("accessibility"),
+    security: value("security"),
+    javascript: value("javascript"),
+    resources: value("resources"),
+    social: value("social"),
+    google: value("google")
+  };
+}
+var SEO_AUDIT_SEVERITIES = ["critical", "warning", "notice"];
+function rule(severity, category, options = {}) {
+  return {
+    severity,
+    category,
+    scope: options.site === true ? "site" : "page",
+    sure: options.sure === true,
+    insight: options.insight === true || options.fact === true,
+    crawlFact: options.fact === true
+  };
+}
+function insight(category, options = {}) {
+  return { ...rule("notice", category, options), insight: true };
+}
+function accessibilityRules(rules) {
+  const entries = Object.entries(rules).map(([id, entry]) => [
+    id,
+    rule(
+      entry.impact === "critical" || entry.impact === "serious" ? "warning" : "notice",
+      "accessibility"
+    )
+  ]);
+  return Object.fromEntries(entries);
+}
+var SEO_AUDIT_RULES = {
+  // Indexing: what answered, what search engines may crawl and are told to index, the crawl files.
+  unreachable: rule("critical", "indexing"),
+  status_client_error: rule("critical", "indexing"),
+  missing_page_with_visitors: rule("warning", "indexing"),
+  status_server_error: rule("critical", "indexing"),
+  crawl_blocked: rule("notice", "indexing"),
+  crawl_rate_limited: rule("notice", "indexing", { site: true }),
+  bad_content_type: rule("notice", "indexing"),
+  soft_404_page: rule("warning", "indexing"),
+  soft_404_catch_all: rule("warning", "indexing", { site: true }),
+  url_too_long: rule("notice", "indexing", { fact: true }),
+  robots_unreachable: rule("critical", "indexing", { site: true }),
+  robots_syntax_error: rule("warning", "indexing", { site: true }),
+  robots_blocked_url: rule("notice", "indexing", { fact: true, site: true }),
+  sitemap_not_in_robots: rule("notice", "indexing", { site: true }),
+  url_multiple_slashes: rule("notice", "indexing"),
+  url_uppercase: rule("notice", "indexing", { fact: true }),
+  url_whitespace: rule("notice", "indexing"),
+  url_non_ascii: rule("notice", "indexing", { fact: true }),
+  url_underscores: rule("notice", "indexing", { fact: true }),
+  url_repetitive_path: rule("notice", "indexing"),
+  url_default_slug: insight("indexing"),
+  url_session_or_tracking: rule("warning", "indexing"),
+  url_parameters: rule("notice", "indexing", { fact: true }),
+  url_internal_search: rule("notice", "indexing"),
+  url_ajax_fragment: rule("notice", "indexing"),
+  url_technical_duplicate: rule("warning", "indexing"),
+  html_structure_broken: rule("notice", "indexing"),
+  html_over_2mb: rule("critical", "indexing", { sure: true }),
+  html_over_2mb_minor: rule("warning", "indexing"),
+  noindex: rule("notice", "indexing", { fact: true }),
+  nofollow: rule("notice", "indexing", { fact: true }),
+  canonical_missing: rule("notice", "indexing"),
+  canonical_elsewhere: rule("notice", "indexing", { fact: true }),
+  canonical_multiple: rule("warning", "indexing"),
+  canonical_conflict: rule("warning", "indexing"),
+  canonical_target_error: rule("critical", "indexing", { sure: true }),
+  canonical_target_redirect: rule("warning", "indexing"),
+  canonical_target_noindex: rule("warning", "indexing"),
+  canonical_unlinked: rule("warning", "indexing"),
+  sitemap_error_url: rule("warning", "indexing"),
+  sitemap_redirect_url: rule("warning", "indexing"),
+  sitemap_noindex_url: rule("warning", "indexing"),
+  checkout_page_indexable: rule("notice", "indexing"),
+  sitemap_non_canonical_url: rule("warning", "indexing"),
+  sitemap_missing: rule("notice", "indexing", { site: true }),
+  sitemap_empty: rule("notice", "indexing", { site: true }),
+  sitemap_lastmod_uniform: rule("notice", "indexing", { site: true }),
+  search_engine_blocked: rule("critical", "indexing", { site: true }),
+  head_invalid_element: rule("critical", "indexing", { sure: true }),
+  directive_outside_head: rule("critical", "indexing", { sure: true }),
+  directives_mismatch: rule("warning", "indexing"),
+  directives_duplicated: rule("notice", "indexing", { fact: true }),
+  search_features_restricted: rule("notice", "indexing"),
+  unavailable_after_passed: rule("warning", "indexing"),
+  canonical_chain: rule("warning", "indexing"),
+  canonical_target_disallowed: rule("warning", "indexing"),
+  canonical_to_home: rule("warning", "indexing", { site: true }),
+  canonical_external: rule("notice", "indexing", { fact: true }),
+  canonical_protocol_mismatch: rule("warning", "indexing", { sure: true }),
+  canonical_invalid: rule("warning", "indexing"),
+  canonical_invalid_attributes: rule("warning", "indexing"),
+  canonical_noindex_conflict: rule("notice", "indexing", { fact: true }),
+  sitemap_disallowed_url: rule("warning", "indexing", { site: true }),
+  sitemap_unreachable: rule("warning", "indexing", { site: true }),
+  sitemap_invalid_xml: rule("warning", "indexing", { site: true }),
+  sitemap_too_big: rule("critical", "indexing", { site: true }),
+  sitemap_out_of_scope: rule("warning", "indexing", { site: true }),
+  sitemap_extension_invalid: rule("warning", "indexing", { site: true }),
+  sitemap_lastmod_invalid: rule("notice", "indexing", { site: true }),
+  sitemap_deprecated_tags: rule("notice", "indexing", { fact: true, site: true }),
+  sitemap_url_in_multiple: rule("notice", "indexing", { fact: true, site: true }),
+  page_not_in_sitemap: rule("notice", "indexing"),
+  paginated_canonical_to_first: rule("warning", "indexing"),
+  pagination_not_linked: rule("notice", "indexing"),
+  pagination_invalid: rule("notice", "indexing", { fact: true }),
+  infinite_scroll_no_pages: rule("notice", "indexing"),
+  amp_status_error: rule("warning", "indexing"),
+  amp_canonical_invalid: rule("warning", "indexing"),
+  amp_missing_return_link: rule("notice", "indexing"),
+  amp_invalid: rule("warning", "indexing"),
+  ai_search_crawlers_blocked: rule("warning", "indexing", { site: true }),
+  ai_bots_inconsistent: rule("notice", "indexing", { fact: true, site: true }),
+  content_signal_missing: rule("notice", "indexing", { fact: true, site: true }),
+  llms_txt_invalid: rule("notice", "indexing", { fact: true, site: true }),
+  markdown_alternate_missing: rule("notice", "indexing", { fact: true, site: true }),
+  well_known_invalid: rule("notice", "indexing", { site: true }),
+  // Redirects.
+  redirect: rule("notice", "redirects", { fact: true }),
+  redirect_chain: rule("warning", "redirects"),
+  redirect_loop: rule("critical", "redirects", { sure: true }),
+  redirect_unlinked: rule("notice", "redirects", { fact: true }),
+  redirect_temporary: rule("notice", "redirects"),
+  redirect_too_many: rule("critical", "redirects"),
+  redirect_broken: rule("critical", "redirects", { sure: true }),
+  redirect_https_to_http: rule("warning", "redirects", { sure: true }),
+  redirect_slash_or_case: rule("notice", "redirects"),
+  redirect_meta_refresh: rule("notice", "redirects"),
+  redirect_http_refresh: rule("notice", "redirects"),
+  redirect_javascript: rule("notice", "redirects"),
+  host_variants_not_redirecting: rule("warning", "redirects", { site: true, sure: true }),
+  host_variants_canonicalised: rule("notice", "redirects", { site: true }),
+  // Links.
+  base_tag_invalid: rule("warning", "links"),
+  broken_internal_links: rule("critical", "links", { sure: true }),
+  links_to_redirect: rule("notice", "links"),
+  orphan: rule("warning", "links"),
+  no_internal_links_out: rule("notice", "links"),
+  links_localhost: rule("critical", "links", { sure: true }),
+  links_localhost_in_text: rule("warning", "links"),
+  links_malformed: rule("warning", "links"),
+  links_space_in_query: rule("notice", "links", { fact: true }),
+  links_uncrawlable: rule("warning", "links"),
+  links_to_http: rule("warning", "links"),
+  links_broken_bookmark: rule("notice", "links"),
+  isolated_page: rule("warning", "links"),
+  inlinks_nofollow_only: rule("warning", "links"),
+  inlinks_follow_nofollow_mix: rule("notice", "links"),
+  outlinks_internal_nofollow: rule("notice", "links"),
+  inlinks_single: rule("notice", "links"),
+  deep_page: rule("notice", "links"),
+  anchor_missing: rule("notice", "links"),
+  anchor_non_descriptive: rule("notice", "links"),
+  outlinks_high: rule("notice", "links", { fact: true }),
+  external_broken: rule("warning", "links"),
+  document_broken: rule("warning", "links"),
+  external_redirect: rule("notice", "links", { fact: true }),
+  // Content: the words on the page and its headings.
+  h1_missing: rule("warning", "content"),
+  h1_multiple: rule("notice", "content"),
+  h1_duplicate: rule("notice", "content"),
+  h1_length: rule("notice", "content", { fact: true }),
+  h2_facts: rule("notice", "content", { fact: true }),
+  heading_skip: rule("notice", "content"),
+  thin_content: rule("notice", "content"),
+  lorem_ipsum: rule("warning", "content", { sure: true }),
+  html_empty: rule("critical", "content", { sure: true }),
+  spelling_errors: insight("content"),
+  spelling_in_title: rule("notice", "content"),
+  low_relevance: rule("notice", "content", { fact: true }),
+  custom_search: insight("content"),
+  linked_documents: rule("notice", "content", { fact: true }),
+  document_title_missing: rule("notice", "content"),
+  custom_script: insight("content"),
+  ai_prompt: insight("content"),
+  grammar_errors: insight("content"),
+  readability_difficult: rule("notice", "content", { fact: true }),
+  content_date_missing: rule("notice", "content", { fact: true }),
+  eeat_signals: insight("content"),
+  duplicate_content: rule("warning", "content"),
+  duplicate_body: rule("warning", "content"),
+  images_missing_alt: rule("notice", "content"),
+  image_alt_quality: insight("content"),
+  // Metadata: titles and meta descriptions.
+  metadata_outside_head: rule("warning", "metadata"),
+  title_missing: rule("critical", "metadata", { sure: true }),
+  title_multiple: rule("warning", "metadata"),
+  title_too_long: rule("notice", "metadata"),
+  title_too_short: rule("notice", "metadata"),
+  title_placeholder: rule("warning", "metadata", { sure: true }),
+  title_same_as_description: rule("notice", "metadata"),
+  title_serp_rewritten: rule("notice", "metadata"),
+  meta_description_missing: rule("notice", "metadata"),
+  meta_description_multiple: rule("warning", "metadata"),
+  meta_description_too_long: rule("notice", "metadata"),
+  meta_description_too_short: rule("notice", "metadata"),
+  meta_description_placeholder: rule("warning", "metadata", { sure: true }),
+  duplicate_title: rule("warning", "metadata"),
+  duplicate_meta_description: rule("notice", "metadata"),
+  metadata_templated: rule("warning", "metadata"),
+  // Structured data.
+  structured_data_missing: rule("notice", "structured_data", { fact: true }),
+  schema_invalid_json: rule("warning", "structured_data", { sure: true }),
+  schema_missing_context: rule("warning", "structured_data"),
+  schema_missing_type: rule("notice", "structured_data"),
+  schema_missing_required: rule("warning", "structured_data"),
+  schema_placeholder: rule("warning", "structured_data"),
+  schema_relative_url: rule("notice", "structured_data"),
+  schema_retired_type: rule("notice", "structured_data", { fact: true }),
+  schema_vocabulary_invalid: rule("warning", "structured_data"),
+  schema_missing_recommended: rule("notice", "structured_data", { insight: true }),
+  schema_type_expected: insight("structured_data"),
+  product_schema_missing: rule("warning", "structured_data"),
+  schema_content_mismatch: rule("warning", "structured_data"),
+  structured_data_truncated: rule("notice", "structured_data", { fact: true }),
+  rich_result_invalid_google: rule("warning", "structured_data"),
+  // International: languages and regions.
+  translation_missing: rule("warning", "international"),
+  lang_missing: rule("notice", "international"),
+  hreflang_invalid_code: rule("warning", "international"),
+  hreflang_relative_url: rule("warning", "international"),
+  hreflang_no_self: rule("warning", "international"),
+  hreflang_no_return: rule("warning", "international"),
+  hreflang_conflict: rule("warning", "international"),
+  hreflang_to_non_canonical: rule("warning", "international"),
+  hreflang_on_canonicalized: rule("warning", "international"),
+  hreflang_missing_x_default: rule("notice", "international"),
+  lang_body_mismatch: rule("warning", "international"),
+  hreflang_target_error: rule("warning", "international"),
+  hreflang_target_not_indexable: rule("warning", "international"),
+  hreflang_inconsistent_codes: rule("warning", "international"),
+  hreflang_lang_mismatch: rule("warning", "international"),
+  hreflang_multiple_methods: rule("notice", "international", { fact: true }),
+  hreflang_sitemap_invalid: rule("warning", "international", { site: true }),
+  hreflang_group_incomplete: rule("notice", "international", { fact: true }),
+  hreflang_page_unreferenced: rule("notice", "international", { fact: true }),
+  hreflang_missing: rule("notice", "international", { site: true }),
+  lang_invalid: rule("warning", "international"),
+  // Performance: response, weight, images and Core Web Vitals, then the lab tests (Lighthouse, run by
+  // PageSpeed Insights on a sample of pages).
+  response_slow: rule("warning", "performance"),
+  response_moderate: rule("notice", "performance", { fact: true }),
+  page_moderate: rule("notice", "performance"),
+  images_lazy_hero: rule("warning", "performance"),
+  images_missing_dimensions: rule("notice", "performance"),
+  compression_missing: rule("warning", "performance"),
+  cache_policy_weak: rule("notice", "performance"),
+  compression_missing_third_party: rule("notice", "performance", { fact: true }),
+  cache_policy_weak_third_party: rule("notice", "performance", { fact: true }),
+  image_incorrectly_sized: rule("notice", "performance"),
+  image_offscreen_eager: rule("notice", "performance"),
+  image_lcp_priority: insight("performance"),
+  image_too_large: rule("notice", "performance"),
+  image_legacy_format: insight("performance"),
+  image_animated_gif: insight("performance"),
+  image_srcset_missing: insight("performance"),
+  network_payload_large: rule("notice", "performance"),
+  document_large: rule("notice", "performance"),
+  dom_size_excessive: rule("notice", "performance"),
+  cwv_lcp_poor: rule("warning", "performance"),
+  cwv_inp_poor: rule("warning", "performance"),
+  cwv_cls_poor: rule("warning", "performance"),
+  cwv_regressed: rule("warning", "performance"),
+  lh_render_blocking: rule("warning", "performance"),
+  lh_document_latency: rule("warning", "performance"),
+  lh_lcp_discovery: rule("warning", "performance"),
+  lh_network_dependency_tree: rule("warning", "performance"),
+  lh_layout_shift_culprits: rule("warning", "performance"),
+  lh_image_delivery: rule("warning", "performance"),
+  lh_forced_reflow: rule("notice", "performance"),
+  lh_legacy_javascript: rule("notice", "performance"),
+  lh_duplicated_javascript: rule("notice", "performance"),
+  lh_unused_css: rule("notice", "performance"),
+  lh_unused_javascript: rule("notice", "performance"),
+  lh_unminified: rule("notice", "performance"),
+  lh_js_execution: rule("notice", "performance"),
+  lh_main_thread: rule("notice", "performance"),
+  lh_font_display: rule("notice", "performance"),
+  lh_performance_score: rule("notice", "performance", { fact: true }),
+  // Mobile.
+  mobile_desktop_parity: rule("critical", "mobile"),
+  unsupported_plugins: rule("notice", "mobile"),
+  viewport_missing: rule("critical", "mobile", { sure: true }),
+  viewport_invalid: rule("notice", "mobile"),
+  viewport_fixed_width: rule("warning", "mobile"),
+  mobile_alternate_link: rule("notice", "mobile", { fact: true }),
+  content_not_sized: rule("warning", "mobile"),
+  content_not_sized_severe: rule("critical", "mobile"),
+  font_too_small: rule("notice", "mobile"),
+  tap_targets_small: rule("notice", "mobile"),
+  intrusive_interstitial: rule("warning", "mobile"),
+  // Accessibility: axe-core's rules, generated.
+  ...accessibilityRules(SEO_A11Y_RULES),
+  // Security.
+  mixed_content_active: rule("critical", "security", { sure: true }),
+  mixed_content_passive: rule("notice", "security"),
+  security_headers_missing: rule("notice", "security", { site: true }),
+  form_insecure: rule("warning", "security", { sure: true }),
+  internal_http_page: rule("warning", "security", { sure: true }),
+  protocol_relative_resources: rule("notice", "security", { fact: true }),
+  tls_certificate: rule("warning", "security", { site: true }),
+  // JavaScript: the page as a browser rendered it, against its raw HTML.
+  render_failed: rule("notice", "javascript", { fact: true }),
+  render_timeout: rule("notice", "javascript", { fact: true }),
+  needs_javascript: rule("notice", "javascript"),
+  js_links_only: rule("notice", "javascript"),
+  js_title_changed: rule("notice", "javascript"),
+  js_h1_changed: rule("notice", "javascript"),
+  js_meta_description_changed: rule("notice", "javascript"),
+  js_canonical_changed: rule("warning", "javascript"),
+  js_canonical_raw_elsewhere: rule("critical", "javascript"),
+  js_noindex_removed: rule("warning", "javascript"),
+  js_noindex_added: rule("warning", "javascript"),
+  js_nofollow_removed: rule("notice", "javascript"),
+  js_structured_data_only: rule("notice", "javascript"),
+  js_hreflang_changed: rule("notice", "javascript"),
+  js_errors: rule("notice", "javascript"),
+  js_back_button_hijack: rule("critical", "javascript"),
+  // Resources: the files the pages load.
+  resources_failed: rule("warning", "resources"),
+  resources_blocked: rule("warning", "resources"),
+  resources_blocked_minor: rule("notice", "resources", { fact: true }),
+  resource_over_2mb: rule("warning", "resources"),
+  image_broken: rule("warning", "resources", { sure: true }),
+  resource_redirect: rule("notice", "resources"),
+  // Social.
+  open_graph_missing: rule("notice", "social"),
+  social_tags_incomplete: rule("notice", "social"),
+  og_url_not_canonical: rule("notice", "social"),
+  og_image_broken: rule("notice", "social"),
+  og_image_too_large: rule("notice", "social"),
+  // Google data: what Search Console, URL Inspection and Analytics say about the pages.
+  error_page_with_traffic: rule("critical", "google", { sure: true }),
+  redirect_with_traffic: rule("notice", "google"),
+  disallowed_with_traffic: rule("warning", "google"),
+  noindex_with_traffic: rule("warning", "google"),
+  canonicalised_with_traffic: rule("notice", "google"),
+  indexable_not_indexed: rule("warning", "google", { fact: true }),
+  google_canonical_differs: rule("warning", "google"),
+  indexed_with_issues: rule("notice", "google"),
+  no_search_data: rule("notice", "google", { fact: true }),
+  analytics_tags: insight("google"),
+  orphan_with_traffic: rule("warning", "google")
+};
+var SEO_AUDIT_RULE_IDS = Object.keys(SEO_AUDIT_RULES);
+function isSeoAuditRuleId(value) {
+  return Object.hasOwn(SEO_AUDIT_RULES, value);
+}
+var SEO_AUDIT_TRAFFIC_JOINS = {
+  status_client_error: "error_page_with_traffic",
+  status_server_error: "error_page_with_traffic",
+  noindex: "noindex_with_traffic",
+  canonical_elsewhere: "canonicalised_with_traffic",
+  orphan: "orphan_with_traffic",
+  redirect: "redirect_with_traffic"
+};
+var SCHEMA_ERRORS = [
+  "schema_invalid_json",
+  "schema_missing_context",
+  "schema_missing_type",
+  "schema_missing_required",
+  "schema_placeholder",
+  "schema_relative_url",
+  "schema_vocabulary_invalid",
+  "schema_content_mismatch"
+];
+var SUPERSEDING = [
+  ["title_missing", ["html_empty"]],
+  ["viewport_missing", ["html_empty"]],
+  ["meta_description_missing", ["html_empty"]],
+  ["lang_missing", ["html_empty"]],
+  ["open_graph_missing", ["html_empty"]],
+  ["no_internal_links_out", ["html_empty"]],
+  ["thin_content", ["html_empty"]],
+  ["h1_missing", ["html_empty"]],
+  ["canonical_elsewhere", ["canonical_target_error", "hreflang_on_canonicalized"]],
+  ["canonical_external", ["canonical_elsewhere"]],
+  ["sitemap_non_canonical_url", ["canonical_target_error"]],
+  [
+    "redirect",
+    [
+      "redirect_chain",
+      "redirect_loop",
+      "redirect_too_many",
+      "redirect_broken",
+      "redirect_temporary",
+      "redirect_https_to_http",
+      "redirect_slash_or_case"
+    ]
+  ],
+  ["redirect_javascript", ["redirect_broken"]],
+  ["rich_result_invalid_google", SCHEMA_ERRORS],
+  ["lang_body_mismatch", ["translation_missing"]],
+  ["duplicate_title", ["title_placeholder"]],
+  ["duplicate_meta_description", ["meta_description_placeholder"]],
+  ["structured_data_missing", ["product_schema_missing", "html_empty"]],
+  ["schema_type_expected", ["product_schema_missing"]]
+];
+function supersededBy() {
+  const direct = new Map(
+    SUPERSEDING.map(([ruleId, by]) => [ruleId, [...by]])
+  );
+  for (const [ruleId, join] of Object.entries(SEO_AUDIT_TRAFFIC_JOINS)) {
+    if (!isSeoAuditRuleId(ruleId) || join === void 0) continue;
+    direct.set(ruleId, [...direct.get(ruleId) ?? [], join]);
+  }
+  const closed = /* @__PURE__ */ new Map();
+  for (const ruleId of direct.keys()) {
+    const all = /* @__PURE__ */ new Set();
+    const queue = [...direct.get(ruleId) ?? []];
+    for (let next = queue.shift(); next !== void 0; next = queue.shift()) {
+      if (next === ruleId || all.has(next)) continue;
+      all.add(next);
+      queue.push(...direct.get(next) ?? []);
+    }
+    closed.set(ruleId, [...all]);
+  }
+  return closed;
+}
+var SEO_AUDIT_SUPERSEDED_BY = supersededBy();
+function seoAuditRule(ruleId) {
+  return isSeoAuditRuleId(ruleId) ? SEO_AUDIT_RULES[ruleId] : null;
+}
+SEO_AUDIT_RULE_IDS.filter(
+  (id) => SEO_AUDIT_RULES[id].sure
+);
+SEO_AUDIT_RULE_IDS.filter(
+  (id) => SEO_AUDIT_RULES[id].insight
+);
+SEO_AUDIT_RULE_IDS.filter(
+  (id) => SEO_AUDIT_RULES[id].crawlFact
+);
+function isSeoAuditCrawlFact(ruleId) {
+  return isSeoAuditRuleId(ruleId) && SEO_AUDIT_RULES[ruleId].crawlFact;
+}
+var HINT_TOPICS = {
+  canonical: [
+    "canonical_missing",
+    "canonical_multiple",
+    "canonical_to_home",
+    "canonical_target_error",
+    "canonical_target_redirect",
+    "canonical_target_noindex",
+    "canonical_protocol_mismatch",
+    "canonical_chain"
+  ],
+  sitemap: [
+    "sitemap_missing",
+    "sitemap_empty",
+    "sitemap_non_canonical_url",
+    "sitemap_noindex_url",
+    "sitemap_redirect_url",
+    "sitemap_error_url",
+    "page_not_in_sitemap"
+  ],
+  titles: [
+    "title_missing",
+    "title_multiple",
+    "title_too_long",
+    "title_too_short",
+    "duplicate_title",
+    "meta_description_missing",
+    "meta_description_multiple",
+    "meta_description_too_long",
+    "meta_description_too_short",
+    "duplicate_meta_description",
+    "title_placeholder",
+    "meta_description_placeholder",
+    "metadata_templated"
+  ],
+  redirects: ["redirect_chain", "redirect_temporary", "redirect_loop", "redirect_too_many"],
+  noindex: ["noindex", "noindex_with_traffic"],
+  structured_data: [
+    "structured_data_missing",
+    "product_schema_missing",
+    "schema_invalid_json",
+    "schema_missing_context",
+    "schema_missing_type",
+    "schema_missing_required",
+    "schema_placeholder",
+    "schema_vocabulary_invalid",
+    "schema_content_mismatch",
+    "schema_relative_url",
+    "rich_result_invalid_google"
+  ],
+  images: ["images_missing_alt"],
+  rendering: ["needs_javascript"],
+  pagination: ["paginated_canonical_to_first"]
+};
+new Map(
+  Object.entries(HINT_TOPICS).flatMap(
+    ([topic, ids]) => ids.map((id) => [id, topic])
+  )
+);
+
+// src/thresholds.ts
+var SEO_AUDIT_THRESHOLD_SPECS = {
+  /** Title width on Google's results page past which it is cut. */
+  titleMaxPx: { value: 580, min: 300, max: 1200, unit: "px", rules: ["title_too_long"] },
+  /** Title width under which it is short. */
+  titleMinPx: { value: 200, min: 0, max: 600, unit: "px", rules: ["title_too_short"] },
+  /** Description width on Google's results page past which it is cut. */
+  descriptionMaxPx: {
+    value: 990,
+    min: 400,
+    max: 2e3,
+    unit: "px",
+    rules: ["meta_description_too_long"]
+  },
+  /** Description width under which it is short. */
+  descriptionMinPx: {
+    value: 400,
+    min: 0,
+    max: 1200,
+    unit: "px",
+    rules: ["meta_description_too_short"]
+  },
+  /** Main-text words under which a page has little text. */
+  thinWords: { value: 300, min: 0, max: 5e3, unit: "words", rules: ["thin_content"] },
+  /** How much two main texts overlap, in percent, from which they are near-duplicates. */
+  nearDuplicatePercent: {
+    value: 90,
+    min: 80,
+    max: 99,
+    unit: "percent",
+    rules: ["duplicate_content"]
+  },
+  /** Server answer time past which a page is very slow (measured from our crawler). */
+  slowMs: { value: 3e3, min: 500, max: 3e4, unit: "ms", rules: ["response_slow"] },
+  /** Server answer time past which a page is slow. */
+  moderateMs: { value: 1500, min: 200, max: 3e4, unit: "ms", rules: ["response_moderate"] },
+  /** HTML size past which a page is heavy (Googlebot reads 2 MB of a file). */
+  pageKb: { value: 1024, min: 100, max: 2048, unit: "kb", rules: ["page_moderate"] },
+  /** Redirect hops from which a chain is filed. */
+  redirectHops: { value: 2, min: 2, max: 10, unit: "hops", rules: ["redirect_chain"] },
+  /** URL length past which a URL is very long. */
+  urlMaxChars: { value: 200, min: 50, max: 2e3, unit: "chars", rules: ["url_too_long"] },
+  /** Clicks from the home page past which a page is deep. */
+  deepClicks: { value: 4, min: 2, max: 20, unit: "clicks", rules: ["deep_page"] },
+  /** The weight an image may have. */
+  imageKb: { value: 100, min: 10, max: 5e3, unit: "kb", rules: ["image_too_large"] }
+};
+var SEO_AUDIT_THRESHOLD_KEYS = Object.keys(
+  SEO_AUDIT_THRESHOLD_SPECS
+);
+var SEO_AUDIT_THRESHOLD_DEFAULTS = Object.fromEntries(
+  SEO_AUDIT_THRESHOLD_KEYS.map((key) => [key, SEO_AUDIT_THRESHOLD_SPECS[key].value])
+);
+var ORDERED_PAIRS = [
+  ["titleMinPx", "titleMaxPx"],
+  ["descriptionMinPx", "descriptionMaxPx"],
+  ["moderateMs", "slowMs"]
+];
+function isSeoAuditThresholdKey(key) {
+  return Object.hasOwn(SEO_AUDIT_THRESHOLD_SPECS, key);
+}
+function customThresholdsOf(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+  const kept = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (!isSeoAuditThresholdKey(key) || typeof raw !== "number" || !Number.isFinite(raw)) continue;
+    const spec = SEO_AUDIT_THRESHOLD_SPECS[key];
+    if (raw < spec.min || raw > spec.max || raw === spec.value) continue;
+    kept[key] = raw;
+  }
+  for (const [low, high] of ORDERED_PAIRS) {
+    const values = auditThresholdsOf(kept);
+    if (values[low] >= values[high]) {
+      delete kept[low];
+      delete kept[high];
+    }
+  }
+  return kept;
+}
+function thresholdOrderProblem(custom) {
+  const values = auditThresholdsOf(custom);
+  return ORDERED_PAIRS.find(([low, high]) => values[low] >= values[high]) ?? null;
+}
+function auditThresholdsOf(custom) {
+  return { ...SEO_AUDIT_THRESHOLD_DEFAULTS, ...custom };
+}
+
+// src/rules/page-state.ts
+var SEO_BOT_AGENT_REFUSED = "status_403_bot";
+var CRAWL_BLOCK_ERRORS = /* @__PURE__ */ new Set([
+  "bot_wall",
+  "blocked",
+  "status_403",
+  SEO_BOT_AGENT_REFUSED,
+  "status_429"
+]);
+var AUDIT_EXAMPLES = 5;
+function thresholdsOf(context) {
+  return auditThresholdsOf(context.site.thresholds);
+}
+var PAGE_REDIRECT_RULES = /* @__PURE__ */ new Set([
+  "redirect_meta_refresh",
+  "redirect_http_refresh",
+  "redirect_javascript"
+]);
+function finding(pageKey, ruleId, params = {}) {
+  return { pageKey, ruleId, severity: SEO_AUDIT_RULES[ruleId].severity, params };
+}
+function crawlBlocked(page) {
+  return page.lastError !== null && CRAWL_BLOCK_ERRORS.has(page.lastError);
+}
+function failureUnconfirmed(page) {
+  return page.lastError !== null && !crawlBlocked(page) && (page.failCount ?? 2) < 2;
+}
+function htmlSnapshot(page) {
+  const snapshot = page.snapshot;
+  if (snapshot === null || page.lastError !== null) return null;
+  if (page.status !== null && (page.status < 200 || page.status >= 300)) return null;
+  if (snapshot.status < 200 || snapshot.status >= 300) return null;
+  const type = (snapshot.contentType ?? "").toLowerCase();
+  return type === "" || type.includes("html") ? snapshot : null;
+}
+function noindexOf(snapshot) {
+  return directivesNoindex(snapshot.metaRobots, snapshot.xRobotsTag);
+}
+function nofollowOf(snapshot) {
+  return directivesNofollow(snapshot.metaRobots, snapshot.xRobotsTag);
+}
+function canonicalKey(page, context) {
+  const raw = page.facts?.canonicals[0] ?? page.snapshot?.canonical ?? page.facts?.headers.linkCanonical ?? "";
+  if (raw === "") return null;
+  const key = normalizePageUrl(raw);
+  return key === null ? null : context.resolve(key);
+}
+function canonicalElsewhere(page, context) {
+  const target = canonicalKey(page, context);
+  return target !== null && target !== context.resolve(page.pageKey);
+}
+var TEMPORARY_REDIRECTS = /* @__PURE__ */ new Set([302, 303, 307]);
+var confirmedCopyQueries = /* @__PURE__ */ new WeakMap();
+function temporaryRedirectTarget(page) {
+  const status = page.status ?? page.snapshot?.status ?? null;
+  if (status === null || !TEMPORARY_REDIRECTS.has(status)) return null;
+  const finalUrl = page.snapshot?.finalUrl ?? "";
+  const targetKey = finalUrl === "" ? null : normalizePageUrl(finalUrl);
+  return targetKey === null || targetKey === page.pageKey ? null : targetKey;
+}
+function namesBack(pageKey, targetKey, context) {
+  const target = context.byKey.get(targetKey);
+  const raw = target?.facts?.canonicals[0] ?? target?.snapshot?.canonical ?? target?.facts?.headers.linkCanonical ?? "";
+  return raw !== "" && normalizePageUrl(raw) === pageKey;
+}
+function appendedQuery(pageKey, targetKey) {
+  if (pageKey.includes("?") || !targetKey.startsWith(`${pageKey}?`)) return null;
+  return targetKey.slice(pageKey.length);
+}
+function copyQueries(context) {
+  const known = confirmedCopyQueries.get(context);
+  if (known !== void 0) return known;
+  const found = /* @__PURE__ */ new Set();
+  for (const page of context.pages) {
+    const targetKey = temporaryRedirectTarget(page);
+    if (targetKey === null || !namesBack(page.pageKey, targetKey, context)) continue;
+    const query = appendedQuery(page.pageKey, targetKey);
+    if (query !== null) found.add(query);
+  }
+  confirmedCopyQueries.set(context, found);
+  return found;
+}
+function copyRedirect(page, context) {
+  const targetKey = temporaryRedirectTarget(page);
+  if (targetKey === null) return false;
+  if ((context.byKey.get(targetKey)?.snapshot ?? null) !== null) {
+    return namesBack(page.pageKey, targetKey, context);
+  }
+  const query = appendedQuery(page.pageKey, targetKey);
+  return query !== null && copyQueries(context).has(query);
+}
+function redirectCopy(page, context) {
+  const raw = page.facts?.canonicals[0] ?? page.snapshot?.canonical ?? page.facts?.headers.linkCanonical ?? "";
+  const sourceKey = raw === "" ? null : normalizePageUrl(raw);
+  if (sourceKey === null || sourceKey === page.pageKey) return false;
+  const source = context.byKey.get(sourceKey);
+  return source !== void 0 && temporaryRedirectTarget(source) === page.pageKey && copyRedirect(source, context);
+}
+function indexableSnapshot(page, context) {
+  const snapshot = htmlSnapshot(page);
+  if (snapshot === null || snapshot.mode === "rendered") return null;
+  if (noindexOf(snapshot) || canonicalElsewhere(page, context)) return null;
+  return snapshot;
+}
+function isHome(page, context) {
+  const home = context.site.homeKey;
+  if (home === null) return page.pageKey.indexOf("/") === page.pageKey.length - 1;
+  return context.resolve(page.pageKey) === context.resolve(home);
+}
+var CHECKOUT_SEGMENT = /^(?:cart|basket|checkouts?|check-out|paypal-checkout|order-confirmation|order-received|order-complete|panier|commande|warenkorb|carrito|winkelwagen|afrekenen|carrello|carrinho|koszyk|varukorg)$/i;
+function checkoutPage(pageKey) {
+  const at = pageKey.indexOf("/");
+  const path = (at < 0 ? "" : pageKey.slice(at)).split(/[?#]/)[0] ?? "";
+  return path.split("/").some((segment) => CHECKOUT_SEGMENT.test(segment.replace(/\.(?:html?|php|aspx)$/i, "")));
+}
+function h1MissingOf(page, snapshot) {
+  const count = page.facts?.page?.h1Count ?? snapshot.h1Count ?? 0;
+  const empty = Math.min(count, page.facts?.page?.h1Empty ?? 0);
+  if ((snapshot.h1 ?? "").trim() !== "") return { missing: false, empty: 0 };
+  return { missing: count === 0 || empty >= count, empty };
+}
+function brokenStatus(status) {
+  return status !== null && (status === 0 || status >= 400);
+}
+var PLATFORM_PATHS = /^\/(?:cdn-cgi\/(?!image\/)|_hcms\/|hs\/)/i;
+function platformManaged(url) {
+  try {
+    return PLATFORM_PATHS.test(new URL(url).pathname);
+  } catch {
+    return false;
+  }
+}
+function onOwnHost(url, siteHost) {
+  return onSiteOrBelow(url, siteHost) && !platformManaged(url);
+}
+
+// src/rules/rendering.ts
+var FETCH_FAILURE = /^(?:Uncaught (?:\(in promise\) )?)?TypeError: (?:Failed to fetch|NetworkError when attempting to fetch resource\.?|Load failed)\s*$/i;
+var CART_OR_PIXEL = /(?:^|[/_.-])(?:carts?|checkouts?|basket|bag|wpm|pixels?|analytics|tracking|gtag|gtm)(?=[/_.?-]|$)/i;
+function contentScript(url) {
+  let path;
+  try {
+    path = new URL(url).pathname;
+  } catch {
+    return false;
+  }
+  return /\.m?js$/i.test(path) && !CART_OR_PIXEL.test(path);
+}
+var RENDERING_THRESHOLDS = {
+  /** Rendered main-text words from which a page's content is judged. */
+  jsContentMinWords: 50,
+  /** The share of the rendered words at or under which the raw HTML lacks the main content. */
+  jsContentRawShare: 0.25
+};
+function kindOf(change) {
+  if (change.raw === "") return "added";
+  if (change.rendered === "") return "removed";
+  return "changed";
+}
+function changeParams(change) {
+  return { change: kindOf(change), raw: change.raw, rendered: change.rendered };
+}
+function rawCanonicalElsewhere(pageKey, change) {
+  if (change.raw === "" || change.rendered === "") return false;
+  const host = hostOfKey(pageKey);
+  const raw = normalizePageUrl(change.raw.trim(), host);
+  return raw !== null && raw !== pageKey && normalizePageUrl(change.rendered.trim(), host) === pageKey;
+}
+function addedSelfCanonical(pageKey, change) {
+  if (kindOf(change) !== "added") return false;
+  return normalizePageUrl(change.rendered.trim(), hostOfKey(pageKey)) === pageKey;
+}
+function renderingFindings(page) {
+  const render = page.facts?.render;
+  if (render == null || htmlSnapshot(page) === null) return [];
+  const key = page.pageKey;
+  if (render.outcome === "failed") {
+    if (render.error === "navigated") return [];
+    return [finding(key, "render_failed", { error: render.error ?? "" })];
+  }
+  const found = [];
+  if (render.outcome === "timeout") {
+    found.push(
+      finding(key, "render_timeout", {
+        seconds: Math.round(seoCrawlerLimits.renderTimeoutMs / 1e3)
+      })
+    );
+  }
+  const t = RENDERING_THRESHOLDS;
+  const words = render.renderedWords ?? 0;
+  const built = words >= t.jsContentMinWords && render.rawWords <= words * t.jsContentRawShare;
+  if (built) {
+    found.push(
+      finding(key, "needs_javascript", { rawWords: render.rawWords, renderedWords: words })
+    );
+  }
+  if (render.jsOnlyLinks.count > 0 && !built) {
+    found.push(
+      finding(key, "js_links_only", {
+        count: render.jsOnlyLinks.count,
+        pages: render.jsOnlyLinks.examples.slice(0, AUDIT_EXAMPLES)
+      })
+    );
+  }
+  const changed = render.changed;
+  const own = (change) => change !== void 0 && !(built && kindOf(change) === "added");
+  if (own(changed.title)) found.push(finding(key, "js_title_changed", changeParams(changed.title)));
+  if (own(changed.metaDescription))
+    found.push(finding(key, "js_meta_description_changed", changeParams(changed.metaDescription)));
+  if (own(changed.h1)) found.push(finding(key, "js_h1_changed", changeParams(changed.h1)));
+  if (changed.canonical !== void 0 && !addedSelfCanonical(key, changed.canonical))
+    found.push(
+      finding(
+        key,
+        rawCanonicalElsewhere(key, changed.canonical) ? "js_canonical_raw_elsewhere" : "js_canonical_changed",
+        changeParams(changed.canonical)
+      )
+    );
+  if (changed.robots !== void 0) {
+    const rawNoindex = directivesNoindex(changed.robots.raw);
+    const renderedNoindex = directivesNoindex(changed.robots.rendered);
+    if (rawNoindex && !renderedNoindex)
+      found.push(finding(key, "js_noindex_removed", { raw: changed.robots.raw }));
+    else if (!rawNoindex && renderedNoindex)
+      found.push(finding(key, "js_noindex_added", { rendered: changed.robots.rendered }));
+    if (!rawNoindex && directivesNofollow(changed.robots.raw) && !directivesNofollow(changed.robots.rendered))
+      found.push(finding(key, "js_nofollow_removed", { raw: changed.robots.raw }));
+  }
+  const added = changed.schemaTypesAdded ?? [];
+  if (added.length > 0) found.push(finding(key, "js_structured_data_only", { types: added }));
+  if (changed.hreflang !== void 0) {
+    found.push(
+      finding(key, "js_hreflang_changed", {
+        rawCount: changed.hreflang.rawCount,
+        renderedCount: changed.hreflang.renderedCount
+      })
+    );
+  }
+  const errors = render.consoleErrors;
+  const onlyBlockedFetches = render.blockedResources.count > 0 && errors.examples.length === errors.count && errors.examples.every((message) => FETCH_FAILURE.test(message));
+  if (errors.count > 0 && !onlyBlockedFetches) {
+    found.push(
+      finding(key, "js_errors", {
+        count: render.consoleErrors.count,
+        messages: render.consoleErrors.examples.slice(0, AUDIT_EXAMPLES)
+      })
+    );
+  }
+  const blocked = render.blockedResources;
+  if (blocked.count > 0) {
+    const contentByScript = words >= t.jsContentMinWords && render.rawWords <= words * t.jsContentRawShare;
+    const needed2 = (blocked.stylesheets ?? 0) > 0 || (blocked.scripts ?? 0) > 0 && contentByScript && blocked.examples.some(contentScript);
+    found.push(
+      finding(key, needed2 ? "resources_blocked" : "resources_blocked_minor", {
+        count: blocked.count,
+        urls: blocked.examples.slice(0, AUDIT_EXAMPLES)
+      })
+    );
+  }
+  const failed = render.failedResources;
+  const siteHost = bareHostOfKey(key);
+  const needed = failed.examples.filter(
+    (failure) => (render.outcome !== "timeout" || failure.status !== null) && (failure.type !== "script" || built || onOwnHost(failure.url, siteHost))
+  );
+  const count = render.outcome !== "timeout" && needed.length === failed.examples.length ? failed.count : needed.length;
+  if (count > 0) {
+    found.push(
+      finding(key, "resources_failed", {
+        count,
+        urls: needed.map((failure) => failure.url).slice(0, AUDIT_EXAMPLES)
+      })
+    );
+  }
+  return found;
+}
+
+// src/rules/head.ts
+var GOOGLEBOT_FILE_BYTES = 2 * 1024 * 1024;
+var DIRECTIVES = ["canonical", "robots", "hreflang"];
+var CHANGE_OF = {
+  canonical: "canonical",
+  robots: "robots",
+  hreflang: "hreflang",
+  title: "title",
+  description: "metaDescription"
+};
+function outsideHead(markup) {
+  const kinds = [];
+  if (markup.canonicals.some((entry) => !entry.inHead)) kinds.push("canonical");
+  if (markup.robots.some((entry) => !entry.inHead)) kinds.push("robots");
+  if (markup.hreflangOutsideHead > 0) kinds.push("hreflang");
+  if (markup.titles.some((entry) => !entry.inHead)) kinds.push("title");
+  if (markup.descriptions.some((entry) => !entry.inHead)) kinds.push("description");
+  return kinds;
+}
+function rawHeadOf(page, markup) {
+  const rendered = page.snapshot?.mode === "browser" || page.fetchMode === "browser";
+  if (!rendered) return markup.head;
+  return page.facts?.render?.rawHead ?? null;
+}
+function headBreakOf(page, markup, raw) {
+  const rendered = page.snapshot?.mode === "browser" || page.fetchMode === "browser";
+  const rawLost = page.facts?.render?.rawOutsideHead;
+  if (rendered && markup.head.breaker != null && rawLost !== void 0) {
+    return { breaker: raw?.breaker ?? null, lost: rawLost };
+  }
+  const changed = page.facts?.render?.changed ?? {};
+  const moved = (kind) => rendered && rawLost !== void 0 && !rawLost.includes(kind) && !(CHANGE_OF[kind] in changed);
+  return {
+    breaker: markup.head.breaker ?? raw?.breaker ?? null,
+    lost: outsideHead(markup).filter((kind) => !moved(kind))
+  };
+}
+function structureProblems(head) {
+  const kinds = [];
+  if (head.htmlTags > 1) kinds.push("multiple_html");
+  if (head.headTags > 1) kinds.push("multiple_head");
+  if (head.bodyTags > 1) kinds.push("multiple_body");
+  if (head.contentBeforeHtml) kinds.push("content_before_html");
+  if (head.headNotFirst) kinds.push("head_not_first");
+  return kinds;
+}
+function baseProblem(markup, pageUrl) {
+  const withHref = markup.bases.filter((base2) => base2.href !== null);
+  if (withHref.length === 0) return null;
+  if (new Set(withHref.map((base2) => base2.href)).size > 1) return "multiple";
+  const base = withHref[0];
+  if (base === void 0 || base.href === null) return null;
+  if (base.href.trim() === "") return null;
+  try {
+    const url = new URL(base.href, pageUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return "malformed";
+  } catch {
+    return "malformed";
+  }
+  return base.inHead ? null : "outside_head";
+}
+function headFindings(page) {
+  const snapshot = htmlSnapshot(page);
+  if (snapshot === null || snapshot.mode === "rendered") return [];
+  const key = page.pageKey;
+  const found = [];
+  const size = page.facts?.sizeBytes ?? snapshot.sizeBytes ?? 0;
+  if (size > GOOGLEBOT_FILE_BYTES) {
+    const cut = page.facts?.htmlCut;
+    const minor = cut !== void 0 && !cut.head && !cut.mainText;
+    found.push(
+      finding(key, minor ? "html_over_2mb_minor" : "html_over_2mb", {
+        bytes: size,
+        max: GOOGLEBOT_FILE_BYTES
+      })
+    );
+  }
+  const markup = page.facts?.markup ?? null;
+  if (markup === null) return found;
+  const raw = rawHeadOf(page, markup);
+  const { breaker, lost } = headBreakOf(page, markup, raw);
+  if (breaker?.inNoscript !== true && lost.length > 0) {
+    if (breaker !== null) {
+      found.push(
+        finding(key, "head_invalid_element", {
+          tag: breaker.tag,
+          line: breaker.line,
+          lost
+        })
+      );
+    } else {
+      const directives = lost.filter((kind) => DIRECTIVES.includes(kind));
+      const metadata = lost.filter((kind) => !DIRECTIVES.includes(kind));
+      if (directives.length > 0) {
+        found.push(finding(key, "directive_outside_head", { elements: directives }));
+      }
+      if (metadata.length > 0) {
+        found.push(finding(key, "metadata_outside_head", { elements: metadata }));
+      }
+    }
+  }
+  const structure = raw === null ? [] : structureProblems(raw);
+  if (structure.length > 0) {
+    found.push(finding(key, "html_structure_broken", { kinds: structure, kind: structure[0] }));
+  }
+  const base = baseProblem(markup, snapshot.finalUrl ?? `https://${key}`);
+  if (base !== null) found.push(finding(key, "base_tag_invalid", { kind: base }));
+  const plugins = markup.plugins.applet + (markup.plugins.legacy ?? 0);
+  if (plugins > 0) found.push(finding(key, "unsupported_plugins", { applets: plugins }));
+  return found;
+}
+function builtByScript(page) {
+  const render = page.facts?.render ?? null;
+  if (render === null) return false;
+  const words = render.renderedWords ?? 0;
+  const t = RENDERING_THRESHOLDS;
+  return words >= t.jsContentMinWords && render.rawWords <= words * t.jsContentRawShare;
+}
+var oversizedResourceFindings = (page, resources) => {
+  const siteHost = bareHostOfKey(page.pageKey);
+  const anyScript = builtByScript(page);
+  const over = resources.filter((resource) => {
+    if (resource.kind !== "script" && resource.kind !== "stylesheet") return false;
+    if (resource.kind === "script" && !anyScript && !onOwnHost(resource.url, siteHost))
+      return false;
+    const bytes = resource.headers?.decodedBytes ?? resource.sizeBytes;
+    return bytes !== null && bytes > GOOGLEBOT_FILE_BYTES;
+  });
+  if (over.length === 0) return [];
+  return [
+    finding(page.pageKey, "resource_over_2mb", {
+      count: over.length,
+      urls: over.map((resource) => resource.url).slice(0, AUDIT_EXAMPLES),
+      max: GOOGLEBOT_FILE_BYTES
+    })
+  ];
+};
+
+// src/fetch.ts
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function toFetchUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+  parsed.protocol = "https:";
+  parsed.hash = "";
+  return parsed.href;
+}
+function failureKind(error) {
+  if (error instanceof Error) {
+    if (error.name === "BlockedUrlError") return "blocked";
+    if (error.name === "TimeoutError" || error.name === "AbortError") return "timeout";
+  }
+  return "network";
+}
+var SEO_OPTIONAL_AUDIT_HEADERS = [
+  "contentType",
+  "contentEncoding",
+  "cacheControl",
+  "contentLanguage",
+  "refresh"
+];
+function optionalAuditHeaders(headers, maxChars) {
+  const kept = {};
+  for (const name of SEO_OPTIONAL_AUDIT_HEADERS) {
+    const value = headers[name];
+    if (value !== void 0) kept[name] = value === null ? null : value.slice(0, maxChars);
+  }
+  return kept;
+}
+var NO_AUDIT_HEADERS = {
+  strictTransportSecurity: null,
+  contentSecurityPolicy: null,
+  xContentTypeOptions: null,
+  xFrameOptions: null,
+  referrerPolicy: null,
+  link: null,
+  contentType: null,
+  contentEncoding: null,
+  cacheControl: null,
+  contentLanguage: null,
+  refresh: null
+};
+function readAuditHeaders(headers) {
+  return {
+    strictTransportSecurity: headers.get("strict-transport-security"),
+    contentSecurityPolicy: headers.get("content-security-policy"),
+    xContentTypeOptions: headers.get("x-content-type-options"),
+    xFrameOptions: headers.get("x-frame-options"),
+    referrerPolicy: headers.get("referrer-policy"),
+    link: headers.get("link"),
+    contentType: headers.get("content-type"),
+    contentEncoding: headers.get("content-encoding"),
+    cacheControl: headers.get("cache-control"),
+    contentLanguage: headers.get("content-language"),
+    refresh: headers.get("refresh")
+  };
+}
+async function fetchResource(url, options) {
+  const started = options.now().getTime();
+  const chain = [];
+  let current = toFetchUrl(url);
+  let spelled = null;
+  const failed = (error) => ({
+    requestedUrl: url,
+    finalUrl: current ?? url,
+    status: chain[0]?.status ?? 0,
+    finalStatus: 0,
+    chain,
+    contentType: null,
+    xRobotsTag: null,
+    auditHeaders: NO_AUDIT_HEADERS,
+    body: null,
+    truncated: false,
+    sizeBytes: 0,
+    responseMs: options.now().getTime() - started,
+    error
+  });
+  if (current === null) return failed("blocked");
+  for (let hop = 0; hop <= options.maxRedirects; hop += 1) {
+    const hopStarted = options.now().getTime();
+    const left = options.timeoutMs - (hopStarted - started);
+    if (left <= 0) return failed("timeout");
+    let response;
+    try {
+      response = await options.fetcher(
+        current,
+        {
+          method: "GET",
+          headers: {
+            "User-Agent": options.userAgent,
+            Accept: options.accept,
+            "Accept-Language": "*"
+          }
+        },
+        left
+      );
+    } catch (error) {
+      return failed(failureKind(error));
+    }
+    chain.push(
+      spelled === null || spelled === current ? { url: current, status: response.status } : { url: current, status: response.status, location: spelled }
+    );
+    const location = response.headers.get("location");
+    if (REDIRECT_STATUSES.has(response.status) && location !== null) {
+      await response.body?.cancel().catch(() => void 0);
+      let next;
+      try {
+        spelled = new URL(location, current).href;
+        next = toFetchUrl(spelled);
+      } catch {
+        next = null;
+      }
+      if (next === null) return failed("blocked");
+      current = next;
+      continue;
+    }
+    let read;
+    try {
+      const { sink } = options;
+      if (sink === void 0) read = await readStreamCapped(response.body, options.maxBytes);
+      else if (response.status >= 200 && response.status < 300) {
+        const contentType = response.headers.get("content-type");
+        const drained = await drainStreamCapped(
+          response.body,
+          options.maxBytes,
+          (bytes) => sink(bytes, contentType)
+        );
+        read = { body: null, ...drained };
+      } else {
+        await response.body?.cancel().catch(() => void 0);
+        read = { body: null, truncated: false, sizeBytes: 0 };
+      }
+    } catch (error) {
+      return failed(failureKind(error));
+    }
+    return {
+      requestedUrl: url,
+      finalUrl: current,
+      status: chain[0]?.status ?? response.status,
+      finalStatus: response.status,
+      chain,
+      contentType: response.headers.get("content-type"),
+      xRobotsTag: response.headers.get("x-robots-tag"),
+      auditHeaders: readAuditHeaders(response.headers),
+      body: read.body,
+      truncated: read.truncated,
+      sizeBytes: read.sizeBytes,
+      responseMs: options.now().getTime() - hopStarted,
+      error: null,
+      retryAfter: response.headers.get("retry-after")
+    };
+  }
+  return failed("too_many_redirects");
+}
+async function decodeServedBody(body, contentType, maxBytes) {
+  let bytes = body.byteLength > maxBytes ? body.subarray(0, maxBytes) : body;
+  if (bytes.byteLength > 2 && bytes[0] === 31 && bytes[1] === 139) {
+    try {
+      bytes = (await gunzipCapped(bytes, maxBytes)).body;
+    } catch {
+      bytes = body.subarray(0, Math.min(body.byteLength, maxBytes));
+    }
+  }
+  const charset = /charset=([^;\s]+)/i.exec(contentType ?? "")?.[1]?.replace(/["']/g, "");
+  let text;
+  try {
+    text = new TextDecoder(charset ?? "utf-8").decode(bytes);
+  } catch {
+    text = new TextDecoder("utf-8").decode(bytes);
+  }
+  return text;
+}
+function withoutNul(text) {
+  return text.replaceAll("\0", "");
+}
+async function decodeBody(body, contentType, maxBytes) {
+  return withoutNul(await decodeServedBody(body, contentType, maxBytes));
+}
+
+export { AUDIT_EXAMPLES, GOOGLEBOT_FILE_BYTES, PAGE_REDIRECT_RULES, RENDERING_THRESHOLDS, SEO_AUDIT_RULES, SEO_AUDIT_SEVERITIES, SEO_AUDIT_SUPERSEDED_BY, SEO_AUDIT_THRESHOLD_KEYS, SEO_AUDIT_THRESHOLD_SPECS, SEO_AUDIT_TRAFFIC_JOINS, SEO_BOT_AGENT_REFUSED, SEO_CRAWL_OPTION_LIMITS, SEO_CRAWL_ROBOTS_GROUPS, SEO_CRAWL_USER_AGENT_PRESETS, SEO_CUSTOM_CHECK_LIMITS, SEO_CUSTOM_CHECK_MATCHES, SEO_CUSTOM_CHECK_MODES, SEO_GRAMMAR_LIMITS, SEO_MARKUP_LIMITS, SEO_READING_LIMITS, SEO_ROBOTS_MAX_BYTES, brokenStatus, canonicalElsewhere, canonicalKey, canonicalMismatch, checkoutPage, compileRobots, compileRobotsPattern, copyRedirect, crawlBlocked, customThresholdsOf, decodeBody, decodeServedBody, directivesNofollow, directivesNoindex, failureUnconfirmed, fetchResource, finding, gunzipCapped, h1MissingOf, headFindings, htmlSnapshot, indexableSnapshot, isHome, isRobotsUnreachable, isSeoAuditCrawlFact, isSeoAuditRuleId, nofollowOf, noindexOf, normalizePageUrl, onOwnHost, optionalAuditHeaders, outsideHead, oversizedResourceFindings, parseRobots, readStreamCapped, redirectCopy, renderingFindings, robotsAllows, robotsDecision, robotsPatternMatches, seoAuditByCategory, seoAuditRule, thresholdOrderProblem, thresholdsOf, toFetchUrl, withoutNul };