@seostudio/audit-engine 0.0.0-stage → 0.1.0

package/dist/chunk-J4ZNQFJO.js

@@ -0,0 +1,733 @@
+import { SEO_READING_LIMITS, toFetchUrl, readStreamCapped, GOOGLEBOT_FILE_BYTES, gunzipCapped } from './chunk-7SGWGESF.js';
+import { seoResourceCheckLimits, isInternalHost, hostGateKey, seoCrawlerLimits, isSharedCdnHost } from './chunk-6QPF6O7D.js';
+
+// src/document-facts.ts
+var DOCUMENT_PATH = /\.(?:pdf|docx?|xlsx?|pptx?|odt|ods|odp|rtf|epub)$/iu;
+var TITLE_CHARS = 300;
+var XMP_WINDOW = 4e3;
+function isDocumentUrl(url) {
+  try {
+    return DOCUMENT_PATH.test(new URL(url).pathname);
+  } catch {
+    return false;
+  }
+}
+function isPdf(url, contentType) {
+  const type = (contentType ?? "").toLowerCase();
+  if (type.includes("application/pdf")) return true;
+  if (type !== "" && !type.includes("octet-stream")) return false;
+  try {
+    return /\.pdf$/iu.test(new URL(url).pathname);
+  } catch {
+    return false;
+  }
+}
+function latin1(bytes) {
+  let text = "";
+  for (let start = 0; start < bytes.length; start += 8192) {
+    text += String.fromCharCode(...bytes.subarray(start, start + 8192));
+  }
+  return text;
+}
+function pdfText(raw) {
+  if (raw.startsWith("\xFE\xFF")) {
+    let text = "";
+    for (let index = 2; index + 1 < raw.length; index += 2) {
+      text += String.fromCharCode(raw.charCodeAt(index) << 8 | raw.charCodeAt(index + 1));
+    }
+    return text;
+  }
+  return raw;
+}
+function literalString(text, start) {
+  let depth = 1;
+  let out = "";
+  for (let index = start; index < text.length && out.length <= TITLE_CHARS * 4; index += 1) {
+    const char = text[index] ?? "";
+    if (char === "\\") {
+      const next = text[index + 1] ?? "";
+      index += 1;
+      if (/[0-7]/u.test(next)) {
+        const octal = /^[0-7]{1,3}/u.exec(text.slice(index, index + 3))?.[0] ?? next;
+        out += String.fromCharCode(Number.parseInt(octal, 8));
+        index += octal.length - 1;
+        continue;
+      }
+      const escapes = { n: "\n", r: "\r", t: "	", b: "\b", f: "\f" };
+      out += escapes[next] ?? (next === "\r" || next === "\n" ? "" : next);
+      continue;
+    }
+    if (char === "(") depth += 1;
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0) return out;
+    }
+    out += char;
+  }
+  return null;
+}
+function keptTitle(value) {
+  const folded = value.replace(new RegExp("\\p{Cc}+", "gu"), " ").replace(/\s+/gu, " ").trim();
+  return folded === "" ? null : folded.slice(0, TITLE_CHARS);
+}
+function dictionaryTitle(text) {
+  for (const match of text.matchAll(/\/Title\s*(\(|<(?!<))/gu)) {
+    const at = (match.index ?? 0) + match[0].length;
+    if (match[1] === "(") {
+      const raw2 = literalString(text, at);
+      const title2 = raw2 === null ? null : keptTitle(pdfText(raw2));
+      if (title2 !== null) return title2;
+      continue;
+    }
+    const close = text.indexOf(">", at);
+    if (close === -1) continue;
+    const hex = text.slice(at, close).replace(/\s+/gu, "");
+    if (!/^[0-9a-f]*$/iu.test(hex)) continue;
+    let raw = "";
+    for (let index = 0; index + 1 < hex.length; index += 2) {
+      raw += String.fromCharCode(Number.parseInt(hex.slice(index, index + 2), 16));
+    }
+    const title = keptTitle(pdfText(raw));
+    if (title !== null) return title;
+  }
+  return null;
+}
+function xmpTitle(text) {
+  const open = text.indexOf("<dc:title>");
+  if (open === -1) return null;
+  const window = text.slice(open, open + XMP_WINDOW);
+  const item = window.indexOf("<rdf:li");
+  const start = item === -1 ? -1 : window.indexOf(">", item);
+  const end = start === -1 ? -1 : window.indexOf("</rdf:li>", start);
+  if (end === -1) return null;
+  const raw = window.slice(start + 1, end);
+  let decoded = raw;
+  try {
+    decoded = new TextDecoder().decode(Uint8Array.from(raw, (char) => char.charCodeAt(0)));
+  } catch {
+    decoded = raw;
+  }
+  return keptTitle(
+    decoded.replace(/&lt;/gu, "<").replace(/&gt;/gu, ">").replace(/&quot;/gu, '"').replace(/&apos;/gu, "'").replace(/&amp;/gu, "&")
+  );
+}
+var ENCRYPTED = /\/Encrypt\s*(?:\d+\s+\d+\s+R|<<)/u;
+function pdfTitleOf(chunks) {
+  const text = chunks.map(latin1).join("\n");
+  if (!text.startsWith("%PDF-")) return null;
+  if (ENCRYPTED.test(text)) return xmpTitle(text);
+  const info = [...text.matchAll(/\/Info\s+(\d+)\s+(\d+)\s+R/gu)].at(-1);
+  let infoRead = info === void 0;
+  if (info !== void 0) {
+    const header = new RegExp(
+      `(?:^|[^0-9])${info[1] ?? ""}\\s+${info[2] ?? ""}\\s+obj\\b`,
+      "u"
+    ).exec(text);
+    if (header !== null) {
+      const start = header.index + header[0].length;
+      const end = text.indexOf("endobj", start);
+      const body = text.slice(start, end === -1 ? void 0 : end);
+      const title = dictionaryTitle(body);
+      if (title !== null) return title;
+      infoRead = end !== -1;
+    }
+  }
+  const xmp = xmpTitle(text);
+  if (xmp !== null) return xmp;
+  return infoRead ? "" : null;
+}
+
+// src/image-size.ts
+function u16be(bytes, at) {
+  return (bytes[at] ?? 0) << 8 | (bytes[at + 1] ?? 0);
+}
+function u16le(bytes, at) {
+  return (bytes[at] ?? 0) | (bytes[at + 1] ?? 0) << 8;
+}
+function u32be(bytes, at) {
+  return u16be(bytes, at) * 65536 + u16be(bytes, at + 2);
+}
+function u24le(bytes, at) {
+  return u16le(bytes, at) + (bytes[at + 2] ?? 0) * 65536;
+}
+function tagAt(bytes, at, tag) {
+  for (let index = 0; index < tag.length; index += 1) {
+    if (bytes[at + index] !== tag.charCodeAt(index)) return false;
+  }
+  return true;
+}
+function sized(width, height) {
+  return width > 0 && height > 0 && width < 1e6 && height < 1e6 ? { width, height } : null;
+}
+function jpegSize(bytes) {
+  let at = 2;
+  while (at + 9 < bytes.length) {
+    if (bytes[at] !== 255) return null;
+    const marker = bytes[at + 1] ?? 0;
+    if (marker === 255) {
+      at += 1;
+      continue;
+    }
+    if (marker === 216 || marker >= 208 && marker <= 215 || marker === 1) {
+      at += 2;
+      continue;
+    }
+    const frame = marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204;
+    if (frame) return sized(u16be(bytes, at + 7), u16be(bytes, at + 5));
+    at += 2 + u16be(bytes, at + 2);
+  }
+  return null;
+}
+function avifSize(bytes) {
+  for (let at = 0; at + 16 <= bytes.length; at += 1) {
+    if (tagAt(bytes, at, "ispe")) return sized(u32be(bytes, at + 8), u32be(bytes, at + 12));
+  }
+  return null;
+}
+function imageSizeOf(bytes) {
+  if (bytes.length < 10) return null;
+  if (bytes[0] === 137 && tagAt(bytes, 1, "PNG") && tagAt(bytes, 12, "IHDR")) {
+    return sized(u32be(bytes, 16), u32be(bytes, 20));
+  }
+  if (tagAt(bytes, 0, "GIF8")) return sized(u16le(bytes, 6), u16le(bytes, 8));
+  if (bytes[0] === 255 && bytes[1] === 216) return jpegSize(bytes);
+  if (tagAt(bytes, 0, "RIFF") && tagAt(bytes, 8, "WEBP")) {
+    if (tagAt(bytes, 12, "VP8 ")) {
+      return sized(u16le(bytes, 26) & 16383, u16le(bytes, 28) & 16383);
+    }
+    if (tagAt(bytes, 12, "VP8L")) {
+      const b0 = bytes[21] ?? 0;
+      const b1 = bytes[22] ?? 0;
+      const b2 = bytes[23] ?? 0;
+      const b3 = bytes[24] ?? 0;
+      return sized(
+        1 + ((b1 & 63) << 8 | b0),
+        1 + ((b3 & 15) << 10 | b2 << 2 | b1 >> 6)
+      );
+    }
+    if (tagAt(bytes, 12, "VP8X")) return sized(1 + u24le(bytes, 24), 1 + u24le(bytes, 27));
+    return null;
+  }
+  if (tagAt(bytes, 4, "ftyp")) return avifSize(bytes);
+  if (tagAt(bytes, 0, "BM") && bytes.length >= 26) {
+    const width = u16le(bytes, 18) + u16le(bytes, 20) * 65536;
+    const raw = u16le(bytes, 22) + u16le(bytes, 24) * 65536;
+    const height = raw > 2147483647 ? 4294967296 - raw : raw;
+    return sized(width, height);
+  }
+  return null;
+}
+var GIF_LOOP_EXTENSIONS = ["NETSCAPE2.0", "ANIMEXTS1.0"];
+function afterGifSubBlocks(bytes, at) {
+  let offset = at;
+  while (offset < bytes.length) {
+    const size = bytes[offset] ?? 0;
+    offset += 1;
+    if (size === 0) return offset;
+    offset += size;
+  }
+  return null;
+}
+function gifAnimated(bytes) {
+  if (!tagAt(bytes, 0, "GIF8") || bytes.length < 13) return false;
+  const flags = bytes[10] ?? 0;
+  let offset = 13 + ((flags & 128) === 0 ? 0 : 3 * 2 ** ((flags & 7) + 1));
+  let frames = 0;
+  while (offset < bytes.length) {
+    const block = bytes[offset];
+    if (block === 59) return false;
+    if (block === 33) {
+      const label = bytes[offset + 1];
+      if (label === 255 && GIF_LOOP_EXTENSIONS.some((tag) => tagAt(bytes, offset + 3, tag)))
+        return true;
+      const next2 = afterGifSubBlocks(bytes, offset + 2);
+      if (next2 === null) return false;
+      offset = next2;
+      continue;
+    }
+    if (block !== 44) return false;
+    frames += 1;
+    if (frames > 1) return true;
+    const local = bytes[offset + 9] ?? 0;
+    offset += 10 + ((local & 128) === 0 ? 0 : 3 * 2 ** ((local & 7) + 1)) + 1;
+    const next = afterGifSubBlocks(bytes, offset);
+    if (next === null) return false;
+    offset = next;
+  }
+  return false;
+}
+
+// src/resources.ts
+var SEO_LINK_SPELLINGS_PER_SITE = 200;
+function resourceUrl(value) {
+  try {
+    const url = new URL(value.trim());
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    url.hash = "";
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+var FAILURE_KINDS = {
+  script: "script",
+  stylesheet: "stylesheet",
+  xhr: "other",
+  fetch: "other",
+  other: "other"
+};
+function isOutboundLink(kind) {
+  return kind === "link";
+}
+var OUTBOUND_REFUSALS = /* @__PURE__ */ new Set([401, 403, 407, 408, 429, 451]);
+function outboundFailure(check) {
+  if (check.error === "dns_not_found") return "gone";
+  if (check.error !== null || check.finalStatus === null) return null;
+  const status = check.finalStatus;
+  if (status >= 400 && status < 500) return OUTBOUND_REFUSALS.has(status) ? null : "gone";
+  if (status >= 500 && status < 600 && status !== 503) return "server";
+  return null;
+}
+function outboundBroken(check) {
+  const failure = outboundFailure(check);
+  if (failure === null || check.failCount < 2) return false;
+  if (failure === "gone") return true;
+  if (check.failingSince === null || check.checkedAt === null) return false;
+  return check.failingSince.toISOString().slice(0, 10) !== check.checkedAt.toISOString().slice(0, 10);
+}
+function resourceKey(url, kind) {
+  return isOutboundLink(kind) || kind === "spelling" ? `${kind}|${url}` : url;
+}
+function linkSpellingToCheck(spelled, fetched) {
+  try {
+    const link = new URL(spelled);
+    const page = new URL(fetched);
+    if (link.protocol !== "http:" && link.protocol !== "https:") return false;
+    return link.host.toLowerCase() === page.host.toLowerCase() && link.pathname !== page.pathname;
+  } catch {
+    return false;
+  }
+}
+function pageResourceRefs(scope, page, rendered) {
+  const seen = /* @__PURE__ */ new Set();
+  const loads = [];
+  const documents = [];
+  const links = [];
+  const add = (into, url, kind, max) => {
+    if (url === null || url.length > SEO_READING_LIMITS.textChars || into.length >= max) return;
+    const key = resourceKey(url, kind);
+    if (seen.has(key)) return;
+    seen.add(key);
+    into.push({ url, kind });
+  };
+  const { resourcesPerPage, outboundLinksPerPage, documentsPerPage } = seoResourceCheckLimits;
+  for (const resource of page.markup?.resources ?? []) {
+    add(loads, resourceUrl(resource.url), resource.kind, resourcesPerPage);
+  }
+  for (const failure of rendered?.failedResources ?? []) {
+    add(loads, resourceUrl(failure.url), FAILURE_KINDS[failure.type], resourcesPerPage);
+  }
+  for (const link of page.links) {
+    let host;
+    try {
+      host = new URL(link.href).hostname.toLowerCase();
+    } catch {
+      continue;
+    }
+    const url = resourceUrl(link.href);
+    if (url !== null && isDocumentUrl(url)) add(documents, url, "document", documentsPerPage);
+    if (isInternalHost(scope, host)) continue;
+    add(links, url, "link", outboundLinksPerPage);
+  }
+  return [...loads, ...documents, ...links];
+}
+
+// src/resource-check.ts
+var SEO_IMAGE_SIZE_MIN_BYTES = 20 * 1024;
+var IMAGE_HEADER_BYTES = 32 * 1024;
+var SEO_COMPRESS_MIN_BYTES = 4 * 1024;
+var DECODE_MIN_BYTES = 16 * 1024;
+var COMPRESSIBLE = /^(?:text\/|application\/(?:[\w.+-]*\+)?(?:javascript|ecmascript|json|xml)|image\/svg\+xml)/i;
+var MEDIA_KINDS = /* @__PURE__ */ new Set([
+  "image",
+  "og_image",
+  "icon",
+  "font",
+  "media"
+]);
+function seoCompressible(kind, contentType) {
+  const type = (contentType ?? "").trim().toLowerCase();
+  if (MEDIA_KINDS.has(kind)) return type.startsWith("image/svg+xml");
+  return COMPRESSIBLE.test(type);
+}
+var HEADER_CHARS = 200;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var HEAD_REFUSED = /* @__PURE__ */ new Set([400, 403, 405, 501]);
+function failureKind(error) {
+  if (error instanceof Error) {
+    if (error.name === "BlockedUrlError") {
+      const reason = "reason" in error ? error.reason : null;
+      if (reason === "not_found") return "dns_not_found";
+      if (reason === "dns_unavailable") return "network";
+      return "blocked";
+    }
+    if (error.name === "TimeoutError" || error.name === "AbortError") return "timeout";
+  }
+  return "network";
+}
+async function follow(url, method, userAgent, fetcher, range = "bytes=0-0", accept = "*/*") {
+  const chain = [];
+  let current = toFetchUrl(url);
+  if (current === null) return { chain, finalUrl: url, response: null, error: "blocked" };
+  for (let hop = 0; hop <= seoCrawlerLimits.maxRedirects; hop += 1) {
+    let response;
+    try {
+      response = await fetcher(
+        current,
+        {
+          method,
+          headers: {
+            "User-Agent": userAgent,
+            Accept: accept,
+            ...method !== "GET" ? {} : range === null ? { "Accept-Encoding": "gzip, deflate, br" } : { Range: range }
+          }
+        },
+        seoCrawlerLimits.timeoutMs
+      );
+    } catch (error) {
+      return { chain, finalUrl: current, response: null, error: failureKind(error) };
+    }
+    chain.push({ url: current, status: response.status });
+    const location = response.headers.get("location");
+    if (!REDIRECT_STATUSES.has(response.status) || location === null) {
+      return { chain, finalUrl: current, response, error: null };
+    }
+    await response.body?.cancel().catch(() => void 0);
+    let next;
+    try {
+      next = toFetchUrl(new URL(location, current).href);
+    } catch {
+      next = null;
+    }
+    if (next === null) return { chain, finalUrl: current, response: null, error: "blocked" };
+    current = next;
+  }
+  return { chain, finalUrl: current, response: null, error: "too_many_redirects" };
+}
+function wholeNumber(value) {
+  if (value === null || !/^\s*\d+\s*$/.test(value)) return null;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function rangeTotal(value) {
+  const total = /\/\s*(\d+)\s*$/.exec(value ?? "")?.[1];
+  return total === void 0 ? null : wholeNumber(total);
+}
+async function sizeOf(response, method) {
+  if (method === "GET" && response.status === 206) {
+    await response.body?.cancel().catch(() => void 0);
+    return rangeTotal(response.headers.get("content-range"));
+  }
+  const length = wholeNumber(response.headers.get("content-length"));
+  if (method === "HEAD" || length !== null) {
+    await response.body?.cancel().catch(() => void 0);
+    return length;
+  }
+  try {
+    return (await readStreamCapped(response.body, seoResourceCheckLimits.maxBodyBytes)).sizeBytes;
+  } catch {
+    return null;
+  }
+}
+async function readingOf(target, hops, method, started, now, measure) {
+  const response = hops.response;
+  let sizeBytes = null;
+  if (response !== null) {
+    if (measure && response.status >= 200 && response.status < 300) {
+      sizeBytes = await sizeOf(response, method);
+    } else {
+      await response.body?.cancel().catch(() => void 0);
+    }
+  }
+  return {
+    url: target.url,
+    kind: target.kind,
+    method: method === "HEAD" ? "head" : "get",
+    status: hops.chain[0]?.status ?? 0,
+    finalStatus: response?.status ?? 0,
+    finalUrl: hops.finalUrl.slice(0, SEO_READING_LIMITS.textChars),
+    chain: hops.chain.map((hop) => ({
+      url: hop.url.slice(0, SEO_READING_LIMITS.textChars),
+      status: hop.status
+    })),
+    contentType: response?.headers.get("content-type")?.slice(0, 200) ?? null,
+    sizeBytes,
+    delivery: measure && response !== null ? keptHeaders(response.headers) : null,
+    responseMs: now().getTime() - started,
+    error: hops.error
+  };
+}
+function keptHeaders(headers) {
+  const cut = (value) => value === null ? null : value.slice(0, HEADER_CHARS);
+  return {
+    cacheControl: cut(headers.get("cache-control")),
+    expires: cut(headers.get("expires")),
+    contentEncoding: cut(headers.get("content-encoding"))
+  };
+}
+async function textEncoding(reading, userAgent, fetcher) {
+  if (reading.delivery == null) return void 0;
+  if (reading.delivery.contentEncoding !== null || !seoCompressible(reading.kind, reading.contentType)) {
+    return void 0;
+  }
+  if (reading.sizeBytes === null || reading.sizeBytes < SEO_COMPRESS_MIN_BYTES) return void 0;
+  if (reading.error !== null || reading.finalStatus < 200 || reading.finalStatus >= 300) {
+    return void 0;
+  }
+  const hops = await follow(reading.finalUrl, "GET", userAgent, fetcher, null);
+  const response = hops.response;
+  if (response === null) return void 0;
+  await response.body?.cancel().catch(() => void 0);
+  if (response.status < 200 || response.status >= 300) return void 0;
+  return response.headers.get("content-encoding")?.slice(0, HEADER_CHARS) ?? null;
+}
+var IMAGE_ACCEPT = "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8";
+function acceptFor(kind) {
+  return kind === "image" ? IMAGE_ACCEPT : "*/*";
+}
+async function imageHeader(target, reading, userAgent, fetcher) {
+  if (target.kind !== "image" && target.kind !== "og_image") return null;
+  if (reading.error !== null || reading.finalStatus < 200 || reading.finalStatus >= 300)
+    return null;
+  const type = (reading.contentType ?? "").toLowerCase();
+  if (!type.startsWith("image/") || type.includes("svg")) return null;
+  if (reading.sizeBytes !== null && reading.sizeBytes < SEO_IMAGE_SIZE_MIN_BYTES) return null;
+  const hops = await follow(
+    reading.finalUrl,
+    "GET",
+    userAgent,
+    fetcher,
+    `bytes=0-${String(IMAGE_HEADER_BYTES - 1)}`,
+    acceptFor(target.kind)
+  );
+  const response = hops.response;
+  if (response === null) return null;
+  if (response.status < 200 || response.status >= 300) {
+    await response.body?.cancel().catch(() => void 0);
+    return null;
+  }
+  try {
+    const { body } = await readStreamCapped(response.body, IMAGE_HEADER_BYTES);
+    return { size: imageSizeOf(body), animated: gifAnimated(body) };
+  } catch {
+    return null;
+  }
+}
+async function checkResource(target, userAgent, deps) {
+  if (target.kind === "spelling") return checkLinkSpelling(target, userAgent, deps);
+  const answer = await checkResourceAnswer(target, userAgent, deps);
+  const encoding = await textEncoding(answer, userAgent, deps.fetch);
+  const reading = encoding === void 0 || answer.delivery == null ? answer : { ...answer, delivery: { ...answer.delivery, contentEncoding: encoding } };
+  const decoded = await decodedSize(target, answer, userAgent, deps.fetch);
+  const measured = decoded === void 0 || reading.delivery == null ? reading : { ...reading, delivery: { ...reading.delivery, decodedBytes: decoded } };
+  const header = await imageHeader(target, measured, userAgent, deps.fetch);
+  const sizedHeader = header?.size == null ? measured : { ...measured, width: header.size.width, height: header.size.height };
+  const sized2 = header?.animated === true && sizedHeader.delivery != null ? { ...sizedHeader, delivery: { ...sizedHeader.delivery, animated: true } } : sizedHeader;
+  if (target.kind !== "document") return sized2;
+  return { ...sized2, title: await documentTitle(sized2, userAgent, deps.fetch) };
+}
+async function rangedBytes(url, range, max, userAgent, fetcher) {
+  const hops = await follow(url, "GET", userAgent, fetcher, range);
+  const response = hops.response;
+  if (response === null) return null;
+  if (response.status < 200 || response.status >= 300) {
+    await response.body?.cancel().catch(() => void 0);
+    return null;
+  }
+  try {
+    const { body } = await readStreamCapped(response.body, max);
+    return { bytes: body, ranged: response.status === 206 };
+  } catch {
+    return null;
+  }
+}
+async function documentTitle(reading, userAgent, fetcher) {
+  if (reading.error !== null || reading.finalStatus < 200 || reading.finalStatus >= 300)
+    return null;
+  if (!isPdf(reading.finalUrl, reading.contentType)) return null;
+  const max = seoResourceCheckLimits.documentTitleBytes;
+  const head = await rangedBytes(
+    reading.finalUrl,
+    `bytes=0-${String(max - 1)}`,
+    max,
+    userAgent,
+    fetcher
+  );
+  if (head === null) return null;
+  const whole = reading.sizeBytes !== null && reading.sizeBytes <= max;
+  if (!head.ranged || whole) return pdfTitleOf([head.bytes]);
+  const tail = await rangedBytes(
+    reading.finalUrl,
+    `bytes=-${String(max)}`,
+    max,
+    userAgent,
+    fetcher
+  );
+  return pdfTitleOf(tail === null || !tail.ranged ? [head.bytes] : [head.bytes, tail.bytes]);
+}
+async function decodedSize(target, reading, userAgent, fetcher) {
+  if (target.kind !== "script" && target.kind !== "stylesheet") return void 0;
+  const encoding = (reading.delivery?.contentEncoding ?? "").trim().toLowerCase();
+  if (encoding === "" || encoding === "identity") return void 0;
+  if (reading.error !== null || reading.finalStatus < 200 || reading.finalStatus >= 300) {
+    return void 0;
+  }
+  if (reading.sizeBytes !== null && reading.sizeBytes < DECODE_MIN_BYTES) return void 0;
+  const hops = await follow(reading.finalUrl, "GET", userAgent, fetcher, null);
+  const response = hops.response;
+  if (response === null) return void 0;
+  if (response.status < 200 || response.status >= 300) {
+    await response.body?.cancel().catch(() => void 0);
+    return void 0;
+  }
+  try {
+    const read = await readStreamCapped(response.body, GOOGLEBOT_FILE_BYTES + 1);
+    const gzip = read.body[0] === 31 && read.body[1] === 139;
+    if (!gzip || read.truncated) return read.sizeBytes;
+    return (await gunzipCapped(read.body, GOOGLEBOT_FILE_BYTES + 1)).sizeBytes;
+  } catch {
+    return void 0;
+  }
+}
+async function checkLinkSpelling(target, userAgent, deps) {
+  const started = deps.now().getTime();
+  const url = toFetchUrl(target.url);
+  const ask = async (method2) => {
+    if (url === null) return { response: null, error: "blocked" };
+    try {
+      const response2 = await deps.fetch(
+        url,
+        {
+          method: method2,
+          headers: {
+            "User-Agent": userAgent,
+            Accept: "*/*",
+            ...method2 === "GET" ? { Range: "bytes=0-0" } : {}
+          }
+        },
+        seoCrawlerLimits.timeoutMs
+      );
+      return { response: response2, error: null };
+    } catch (error) {
+      return { response: null, error: failureKind(error) };
+    }
+  };
+  let method = "HEAD";
+  let answer = await ask(method);
+  const recheck = answer.response?.status ?? 0;
+  if (HEAD_REFUSED.has(recheck) || recheck === 404 || recheck === 410) {
+    await answer.response?.body?.cancel().catch(() => void 0);
+    method = "GET";
+    answer = await ask(method);
+  }
+  const response = answer.response;
+  await response?.body?.cancel().catch(() => void 0);
+  const status = response?.status ?? 0;
+  const location = REDIRECT_STATUSES.has(status) ? response?.headers.get("location") : null;
+  let finalUrl = url ?? target.url;
+  if (location !== null && location !== void 0) {
+    try {
+      finalUrl = new URL(location, finalUrl).href;
+    } catch {
+      finalUrl = url ?? target.url;
+    }
+  }
+  return {
+    url: target.url,
+    kind: target.kind,
+    method: method === "HEAD" ? "head" : "get",
+    status,
+    finalStatus: status,
+    finalUrl: finalUrl.slice(0, SEO_READING_LIMITS.textChars),
+    chain: response === null ? [] : [{ url: (url ?? target.url).slice(0, SEO_READING_LIMITS.textChars), status }],
+    contentType: null,
+    sizeBytes: null,
+    delivery: null,
+    responseMs: deps.now().getTime() - started,
+    error: answer.error
+  };
+}
+async function checkResourceAnswer(target, userAgent, deps) {
+  const started = deps.now().getTime();
+  const measure = !isOutboundLink(target.kind);
+  const accept = acceptFor(target.kind);
+  const head = await follow(target.url, "HEAD", userAgent, deps.fetch, void 0, accept);
+  const finalStatus = head.response?.status ?? 0;
+  const refused = head.response !== null && (HEAD_REFUSED.has(finalStatus) || !measure && finalStatus >= 400 && finalStatus !== 429);
+  const sizeUnknown = measure && head.response !== null && finalStatus >= 200 && finalStatus < 300 && wholeNumber(head.response.headers.get("content-length")) === null;
+  if (!refused && !sizeUnknown) {
+    return readingOf(target, head, "HEAD", started, deps.now, measure);
+  }
+  await head.response?.body?.cancel().catch(() => void 0);
+  const get = await follow(target.url, "GET", userAgent, deps.fetch, void 0, accept);
+  if (sizeUnknown && get.response === null) {
+    return readingOf(target, head, "HEAD", started, deps.now, false);
+  }
+  return readingOf(target, get, "GET", started, deps.now, measure);
+}
+function hostOf(url) {
+  try {
+    return new URL(url).host.toLowerCase();
+  } catch {
+    return url;
+  }
+}
+var SEO_RESOURCE_HOSTS_AT_ONCE = 4;
+async function readResources(targets, userAgent, deps, options) {
+  const nextAt = /* @__PURE__ */ new Map();
+  const siteHost = options.siteHost === void 0 ? null : hostGateKey(options.siteHost);
+  const delayOf = (host) => siteHost === null || host === siteHost ? options.delayMs : Math.min(options.delayMs, seoCrawlerLimits.minDelayMs);
+  const paced = async (url, init, timeoutMs) => {
+    const host = hostGateKey(hostOf(url));
+    const delayMs = isSharedCdnHost(host) ? Math.min(delayOf(host), seoResourceCheckLimits.sharedCdnDelayMs) : delayOf(host);
+    const now = deps.now().getTime();
+    const wait = deps.hostGate !== void 0 ? await deps.hostGate.reserve(host, delayMs, now) : Math.max(0, (nextAt.get(host) ?? now) - now);
+    nextAt.set(host, Math.max(nextAt.get(host) ?? 0, now + wait + delayMs));
+    if (wait > 0) await deps.sleep(wait);
+    try {
+      return await deps.fetch(url, init, timeoutMs);
+    } finally {
+      nextAt.set(host, Math.max(nextAt.get(host) ?? 0, deps.now().getTime() + delayMs));
+    }
+  };
+  const byHost = /* @__PURE__ */ new Map();
+  for (const [index, target] of targets.entries()) {
+    const host = hostGateKey(hostOf(target.url));
+    const queue = byHost.get(host);
+    if (queue === void 0) byHost.set(host, [index]);
+    else queue.push(index);
+  }
+  const queues = [...byHost.values()];
+  const readings = [];
+  let stopped = false;
+  const lane = async () => {
+    for (let queue = queues.shift(); queue !== void 0; queue = queues.shift()) {
+      for (const index of queue) {
+        const target = targets[index];
+        if (target === void 0) continue;
+        if (stopped || options.stop?.() === true) {
+          stopped = true;
+          return;
+        }
+        options.onCheck?.(target.url);
+        readings[index] = await checkResource(target, userAgent, { fetch: paced, now: deps.now });
+      }
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(SEO_RESOURCE_HOSTS_AT_ONCE, queues.length) }, lane)
+  );
+  return readings.filter((reading) => reading !== void 0);
+}
+
+export { SEO_COMPRESS_MIN_BYTES, SEO_IMAGE_SIZE_MIN_BYTES, SEO_LINK_SPELLINGS_PER_SITE, SEO_RESOURCE_HOSTS_AT_ONCE, isOutboundLink, linkSpellingToCheck, outboundBroken, outboundFailure, pageResourceRefs, readResources, seoCompressible };