metanova 0.1.0

package/dist/index.js

@@ -0,0 +1,3674 @@
+// src/utils/url.ts
+import net from "net";
+var SHORT_URL_HOSTS = {
+  "pin.it": "Pinterest",
+  "redd.it": "Reddit",
+  "t.co": "X",
+  "bit.ly": "Bitly",
+  "tinyurl.com": "TinyURL",
+  "youtu.be": "YouTube"
+};
+function validateUrl(input, options = {}) {
+  const url = new URL(input);
+  const allowedProtocols = options.allowedProtocols ?? ["http:", "https:"];
+  if (!allowedProtocols.includes(url.protocol)) {
+    throw new TypeError(`Unsupported URL protocol: ${url.protocol}`);
+  }
+  return url;
+}
+function resolveUrl(url, baseUrl) {
+  const resolved = baseUrl ? new URL(url, baseUrl) : new URL(url);
+  return normalizeUrl(resolved.toString());
+}
+function tryResolveUrl(url, baseUrl) {
+  if (!url) {
+    return void 0;
+  }
+  try {
+    return resolveUrl(url, baseUrl);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeUrl(input, options = {}) {
+  const url = validateUrl(input, options);
+  url.hash = "";
+  url.hostname = url.hostname.toLowerCase();
+  if (url.protocol === "http:" && url.port === "80" || url.protocol === "https:" && url.port === "443") {
+    url.port = "";
+  }
+  return url.toString();
+}
+function detectShortUrl(input) {
+  const url = typeof input === "string" ? validateUrl(input) : input;
+  const hostname = url.hostname.toLowerCase().replace(/^www\./, "");
+  const provider = SHORT_URL_HOSTS[hostname];
+  return {
+    isShortUrl: Boolean(provider),
+    provider
+  };
+}
+function resolveCanonicalUrl(canonicalUrl, baseUrl) {
+  return tryResolveUrl(canonicalUrl, baseUrl);
+}
+function isLocalHostname(hostname) {
+  const normalized = hostname.toLowerCase().replace(/\.$/, "");
+  return normalized === "localhost" || normalized.endsWith(".localhost");
+}
+function classifyIp(address) {
+  const ipVersion = net.isIP(address);
+  if (ipVersion === 4) {
+    return classifyIpv4(address);
+  }
+  if (ipVersion === 6) {
+    return classifyIpv6(address);
+  }
+  return "public";
+}
+function classifyIpv4(address) {
+  const parts = address.split(".").map((part) => Number.parseInt(part, 10));
+  const [a, b] = parts;
+  if (a === 127) {
+    return "loopback";
+  }
+  if (a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168) {
+    return "private";
+  }
+  if (a === 169 && b === 254) {
+    return "linkLocal";
+  }
+  if (a === 0 || a >= 224 || a === 100 && b >= 64 && b <= 127 || a === 192 && b === 0 || a === 198 && (b === 18 || b === 19)) {
+    return "reserved";
+  }
+  return "public";
+}
+function classifyIpv6(address) {
+  const normalized = address.toLowerCase();
+  if (normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") {
+    return "loopback";
+  }
+  if (normalized.startsWith("fc") || normalized.startsWith("fd")) {
+    return "private";
+  }
+  if (normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb")) {
+    return "linkLocal";
+  }
+  if (normalized === "::" || normalized.startsWith("::ffff:127.") || normalized.startsWith("::ffff:10.")) {
+    return "reserved";
+  }
+  return "public";
+}
+
+// src/fetcher/security.ts
+import { lookup } from "dns/promises";
+import net2 from "net";
+var SecurityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SecurityError";
+  }
+};
+async function assertSafeRequestUrl(input, options = {}) {
+  const protocols = options.allowedProtocols ?? ["http:", "https:"];
+  let normalizedUrl;
+  try {
+    normalizedUrl = normalizeUrl(input, { allowedProtocols: protocols });
+  } catch (error) {
+    if (error instanceof TypeError) {
+      throw new SecurityError(error.message);
+    }
+    throw error;
+  }
+  const url = new URL(normalizedUrl);
+  if (!protocols.includes(url.protocol)) {
+    throw new SecurityError(`Unsupported URL protocol: ${url.protocol}`);
+  }
+  const hostname = url.hostname;
+  if (isLocalHostname(hostname) && !options.allowLocalhost) {
+    throw new SecurityError("Localhost URLs are blocked by default.");
+  }
+  const literalIp = net2.isIP(hostname) ? hostname : void 0;
+  if (literalIp) {
+    assertPublicAddressAllowed(literalIp, options);
+    return url.toString();
+  }
+  if (options.allowPrivateNetwork && options.allowLocalhost) {
+    return url.toString();
+  }
+  const records = await lookup(hostname, { all: true, verbatim: false });
+  for (const record of records) {
+    assertPublicAddressAllowed(record.address, options);
+  }
+  return url.toString();
+}
+function assertPublicAddressAllowed(address, options) {
+  const classification = classifyIp(address);
+  if (classification === "loopback" && !options.allowLocalhost) {
+    throw new SecurityError(`Loopback address is blocked: ${address}`);
+  }
+  if (classification !== "public" && classification !== "loopback" && !options.allowPrivateNetwork) {
+    throw new SecurityError(`Private or reserved network address is blocked: ${address}`);
+  }
+}
+
+// src/fetcher/fetcher.ts
+var DEFAULT_TIMEOUT_MS = 8e3;
+var DEFAULT_MAX_REDIRECTS = 5;
+var DEFAULT_MAX_BYTES = 2e6;
+var DEFAULT_BROWSER_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36";
+var DEFAULT_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7";
+var DEFAULT_ACCEPT_LANGUAGE = "en-US,en;q=0.9";
+var DEFAULT_ACCEPT_ENCODING = "gzip, deflate, br";
+async function fetchPage(inputUrl, options = {}) {
+  const startUrl = normalizeUrl(inputUrl);
+  const cached = await options.cache?.get(startUrl);
+  if (cached) {
+    return fromCache(startUrl, cached);
+  }
+  const retries = options.retries ?? 1;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    try {
+      const page = await requestWithRedirects(startUrl, options);
+      await options.cache?.set(startUrl, {
+        html: page.html,
+        finalUrl: page.finalUrl,
+        statusCode: page.statusCode,
+        contentType: page.contentType,
+        redirects: page.redirects
+      });
+      return page;
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        await delay(options.retryDelayMs ?? 250);
+      }
+    }
+  }
+  throw lastError;
+}
+async function resolveRedirects(inputUrl, options = {}) {
+  const originalUrl = normalizeUrl(inputUrl);
+  const maxRedirects = options.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+  const fetchImpl = options.fetch ?? fetch;
+  const redirects = [];
+  let currentUrl = await assertSafeRequestUrl(originalUrl, options);
+  for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount += 1) {
+    const response = await requestOnce(fetchImpl, currentUrl, options);
+    const statusCode = response.status;
+    if (!isRedirect(statusCode)) {
+      const shortUrl = detectShortUrl(originalUrl);
+      return {
+        originalUrl,
+        finalUrl: currentUrl,
+        redirects,
+        isShortUrl: shortUrl.isShortUrl,
+        shortUrlProvider: shortUrl.provider
+      };
+    }
+    const location = response.headers.get("location");
+    if (!location) {
+      throw new Error(`Redirect response from ${currentUrl} did not include a Location header.`);
+    }
+    const nextUrl = await assertSafeRequestUrl(resolveUrl(location, currentUrl), options);
+    redirects.push({ from: currentUrl, to: nextUrl, statusCode });
+    currentUrl = nextUrl;
+  }
+  throw new Error(`Too many redirects. Maximum allowed redirects: ${maxRedirects}.`);
+}
+async function requestWithRedirects(inputUrl, options) {
+  const fetchImpl = options.fetch ?? fetch;
+  const maxRedirects = options.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+  const redirects = [];
+  const shortUrl = detectShortUrl(inputUrl);
+  let currentUrl = await assertSafeRequestUrl(inputUrl, options);
+  for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount += 1) {
+    const response = await requestOnce(fetchImpl, currentUrl, options);
+    const statusCode = response.status;
+    if (isRedirect(statusCode)) {
+      const location = response.headers.get("location");
+      if (!location) {
+        throw new Error(`Redirect response from ${currentUrl} did not include a Location header.`);
+      }
+      const nextUrl = await assertSafeRequestUrl(resolveUrl(location, currentUrl), options);
+      redirects.push({ from: currentUrl, to: nextUrl, statusCode });
+      currentUrl = nextUrl;
+      continue;
+    }
+    const headers = headersToRecord(response.headers);
+    const body = await readLimitedBody(response, options.maxBytes ?? DEFAULT_MAX_BYTES);
+    return {
+      url: inputUrl,
+      originalUrl: inputUrl,
+      finalUrl: currentUrl,
+      isShortUrl: shortUrl.isShortUrl,
+      shortUrlProvider: shortUrl.provider,
+      html: body.text,
+      bytes: body.bytes,
+      statusCode,
+      contentType: response.headers.get("content-type") ?? void 0,
+      redirects,
+      headers
+    };
+  }
+  throw new Error(`Too many redirects. Maximum allowed redirects: ${maxRedirects}.`);
+}
+async function requestOnce(fetchImpl, url, options) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(new Error("Request timed out.")), options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const externalSignal = options.signal;
+  const abortFromExternal = () => controller.abort(externalSignal?.reason);
+  if (externalSignal) {
+    if (externalSignal.aborted) {
+      controller.abort(externalSignal.reason);
+    } else {
+      externalSignal.addEventListener("abort", abortFromExternal, { once: true });
+    }
+  }
+  try {
+    return await fetchImpl(url, {
+      redirect: "manual",
+      signal: controller.signal,
+      headers: buildBrowserLikeHeaders(options)
+    });
+  } finally {
+    clearTimeout(timeout);
+    externalSignal?.removeEventListener("abort", abortFromExternal);
+  }
+}
+function buildBrowserLikeHeaders(options) {
+  return {
+    "accept": options.accept ?? DEFAULT_ACCEPT,
+    "accept-language": options.acceptLanguage ?? DEFAULT_ACCEPT_LANGUAGE,
+    "accept-encoding": options.acceptEncoding ?? DEFAULT_ACCEPT_ENCODING,
+    "cache-control": "no-cache",
+    "pragma": "no-cache",
+    "sec-ch-ua": '"Chromium";v="125", "Google Chrome";v="125", "Not.A/Brand";v="24"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "none",
+    "sec-fetch-user": "?1",
+    "upgrade-insecure-requests": "1",
+    "user-agent": options.userAgent ?? DEFAULT_BROWSER_USER_AGENT,
+    ...headersToObject(options.headers)
+  };
+}
+async function readLimitedBody(response, maxBytes) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && Number.parseInt(contentLength, 10) > maxBytes) {
+    throw new Error(`Response body exceeds maxBytes (${maxBytes}).`);
+  }
+  if (!response.body) {
+    const text = await response.text();
+    return {
+      text,
+      bytes: new TextEncoder().encode(text)
+    };
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let received = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (value) {
+      received += value.byteLength;
+      if (received > maxBytes) {
+        throw new Error(`Response body exceeds maxBytes (${maxBytes}).`);
+      }
+      chunks.push(value);
+    }
+  }
+  const buffer = new Uint8Array(received);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buffer.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return {
+    text: decodeBytes(buffer, response.headers.get("content-type")),
+    bytes: buffer
+  };
+}
+function fromCache(url, entry) {
+  const shortUrl = detectShortUrl(url);
+  return {
+    url,
+    originalUrl: url,
+    finalUrl: entry.finalUrl ?? url,
+    isShortUrl: shortUrl.isShortUrl,
+    shortUrlProvider: shortUrl.provider,
+    html: entry.html,
+    statusCode: entry.statusCode ?? 200,
+    contentType: entry.contentType,
+    redirects: entry.redirects ?? [],
+    headers: {}
+  };
+}
+function isRedirect(statusCode) {
+  return statusCode === 301 || statusCode === 302 || statusCode === 303 || statusCode === 307 || statusCode === 308;
+}
+function extractCharset(contentType) {
+  const charset = contentType?.match(/charset=([^;]+)/i)?.[1]?.trim().replace(/^["']|["']$/g, "");
+  return charset || "utf-8";
+}
+function decodeBytes(buffer, contentType) {
+  try {
+    return new TextDecoder(extractCharset(contentType)).decode(buffer);
+  } catch {
+    return new TextDecoder("utf-8").decode(buffer);
+  }
+}
+function headersToRecord(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function headersToObject(headers) {
+  if (!headers) {
+    return {};
+  }
+  return Object.fromEntries(new Headers(headers).entries());
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/utils/html.ts
+import { load } from "cheerio";
+function loadDocument(html) {
+  return load(html);
+}
+function normalizeWhitespace(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function firstDefined(...values) {
+  for (const value of values) {
+    if (value !== void 0 && value !== null && value !== false && value !== "") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function parseInteger(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.round(value);
+  }
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number.parseFloat(String(value));
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function readMetaContent($, selectors) {
+  for (const selector of selectors) {
+    const content = normalizeWhitespace($(selector).first().attr("content"));
+    if (content) {
+      return content;
+    }
+  }
+  return void 0;
+}
+function setMapValue(map, key, value) {
+  const current = map[key];
+  if (Array.isArray(current)) {
+    current.push(value);
+    return;
+  }
+  if (typeof current === "string") {
+    map[key] = [current, value];
+    return;
+  }
+  map[key] = value;
+}
+function splitList(value) {
+  if (!value) {
+    return void 0;
+  }
+  const items = value.split(",").map((item) => normalizeWhitespace(item)).filter((item) => Boolean(item));
+  return items.length > 0 ? items : void 0;
+}
+function parseSrcset(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((candidate) => candidate.trim().split(/\s+/)[0]).filter(Boolean);
+}
+function uniqueMediaByUrl(assets) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const asset of assets) {
+    const key = asset.url;
+    if (!key || seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    unique.push(asset);
+  }
+  return unique;
+}
+function createEmptyDiagnostics() {
+  return {
+    redirects: [],
+    sourcesUsed: [],
+    warnings: [],
+    trace: [],
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/extractors/html.ts
+function extractHtmlMetadata(html) {
+  const $ = loadDocument(html);
+  const favicons = [];
+  const alternates = [];
+  let canonicalUrl;
+  let imageSrc;
+  $("link[rel][href]").each((_, element) => {
+    const rel = normalizeWhitespace($(element).attr("rel"))?.toLowerCase();
+    const href = normalizeWhitespace($(element).attr("href"));
+    const type = normalizeWhitespace($(element).attr("type"));
+    if (!rel || !href) {
+      return;
+    }
+    const relTokens = rel.split(/\s+/);
+    if (relTokens.includes("canonical")) {
+      canonicalUrl = href;
+    }
+    if (relTokens.includes("image_src")) {
+      imageSrc = {
+        url: href,
+        kind: "image",
+        source: "html"
+      };
+    }
+    if (relTokens.includes("alternate")) {
+      alternates.push({
+        href,
+        type,
+        hreflang: normalizeWhitespace($(element).attr("hreflang")),
+        title: normalizeWhitespace($(element).attr("title"))
+      });
+    }
+    if (relTokens.includes("icon") || relTokens.includes("shortcut") || relTokens.includes("apple-touch-icon") || relTokens.includes("mask-icon")) {
+      favicons.push({
+        url: href,
+        kind: "favicon",
+        source: "favicon",
+        type,
+        metadata: {
+          sizes: normalizeWhitespace($(element).attr("sizes")),
+          rel
+        }
+      });
+    }
+  });
+  return {
+    title: normalizeWhitespace($("title").first().text()) ?? readMetaContent($, ["meta[name='title']"]),
+    description: readMetaContent($, ["meta[name='description']", "meta[itemprop='description']"]),
+    keywords: splitList(readMetaContent($, ["meta[name='keywords']"])),
+    robots: readMetaContent($, ["meta[name='robots']"]),
+    canonicalUrl,
+    manifestUrl: normalizeWhitespace($("link[rel='manifest']").first().attr("href")),
+    themeColor: readMetaContent($, ["meta[name='theme-color']"]),
+    applicationName: readMetaContent($, ["meta[name='application-name']", "meta[name='apple-mobile-web-app-title']"]),
+    favicons,
+    imageSrc,
+    alternates
+  };
+}
+
+// src/extractors/embeddedData.ts
+var MAX_SCRIPT_CHARS = 15e5;
+var ASSIGNMENT_PATTERNS = [
+  { source: "nuxt", names: ["window.__NUXT__", "__NUXT__"] },
+  { source: "initialState", names: ["window.__INITIAL_STATE__", "__INITIAL_STATE__"] },
+  { source: "preloadedState", names: ["window.__PRELOADED_STATE__", "__PRELOADED_STATE__"] },
+  { source: "apollo", names: ["window.__APOLLO_STATE__", "__APOLLO_STATE__", "window.__APOLLO_CLIENT__"] },
+  { source: "youtubeInitialData", names: ["ytInitialData", "window.ytInitialData"] },
+  { source: "youtubePlayerResponse", names: ["ytInitialPlayerResponse", "window.ytInitialPlayerResponse"] }
+];
+function extractEmbeddedData(html) {
+  const $ = loadDocument(html);
+  const items = [];
+  const warnings = [];
+  const nextData = parseJsonScript($("#__NEXT_DATA__").first().html() ?? $("#__NEXT_DATA__").first().text(), "nextData", warnings);
+  if (nextData) {
+    items.push(nextData);
+  }
+  const nuxtData = parseJsonScript($("#__NUXT_DATA__").first().html() ?? $("#__NUXT_DATA__").first().text(), "nuxt", warnings);
+  if (nuxtData) {
+    items.push(nuxtData);
+  }
+  $("script").each((index, element) => {
+    const type = normalizeWhitespace($(element).attr("type"))?.toLowerCase();
+    const id = normalizeWhitespace($(element).attr("id"));
+    const source = $(element).html() ?? $(element).text();
+    if (!source || source.length > MAX_SCRIPT_CHARS) {
+      return;
+    }
+    if (type?.includes("application/json") || type?.includes("application/ld+json")) {
+      const parsed = parseJsonScript(source, type?.includes("ld+json") ? "jsonScript" : "applicationJson", warnings, id);
+      if (parsed) {
+        items.push(parsed);
+      }
+    }
+    for (const pattern of ASSIGNMENT_PATTERNS) {
+      for (const name of pattern.names) {
+        const data = parseAssignedJson(source, name);
+        if (data) {
+          items.push({
+            source: pattern.source,
+            path: name,
+            data
+          });
+        }
+      }
+    }
+    const apolloLike = findApolloPayload(source);
+    if (apolloLike) {
+      items.push({
+        source: "apollo",
+        path: `script[${index}]`,
+        data: apolloLike
+      });
+    }
+  });
+  return {
+    items: dedupeEmbeddedItems(items),
+    warnings
+  };
+}
+function parseJsonScript(source, itemSource, warnings, path) {
+  const cleanSource = cleanJsonSource(source);
+  if (!cleanSource) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(cleanSource);
+    if (!isRecord(parsed)) {
+      return void 0;
+    }
+    return {
+      source: itemSource,
+      path,
+      data: parsed
+    };
+  } catch (error) {
+    warnings.push(`Could not parse ${itemSource} embedded JSON${path ? ` at ${path}` : ""}: ${error instanceof Error ? error.message : String(error)}`);
+    return void 0;
+  }
+}
+function parseAssignedJson(source, assignmentName) {
+  const index = source.indexOf(assignmentName);
+  if (index === -1) {
+    return void 0;
+  }
+  const afterName = source.slice(index + assignmentName.length);
+  const assignmentIndex = afterName.search(/=\s*[[{]/);
+  if (assignmentIndex === -1) {
+    return void 0;
+  }
+  const startInAfterName = afterName.slice(assignmentIndex).search(/[[{]/);
+  if (startInAfterName === -1) {
+    return void 0;
+  }
+  const start = index + assignmentName.length + assignmentIndex + startInAfterName;
+  const candidate = readBalancedJson(source, start);
+  if (!candidate) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(candidate);
+    return isRecord(parsed) ? parsed : { value: parsed };
+  } catch {
+    return void 0;
+  }
+}
+function findApolloPayload(source) {
+  if (!/apollo|__APOLLO/i.test(source)) {
+    return void 0;
+  }
+  const data = parseAssignedJson(source, "window.__APOLLO_STATE__") ?? parseAssignedJson(source, "__APOLLO_STATE__");
+  if (data) {
+    return data;
+  }
+  return void 0;
+}
+function readBalancedJson(source, start) {
+  const opener = source[start];
+  const closer = opener === "{" ? "}" : opener === "[" ? "]" : void 0;
+  if (!closer) {
+    return void 0;
+  }
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < source.length; index += 1) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === opener) {
+      depth += 1;
+    } else if (char === closer) {
+      depth -= 1;
+      if (depth === 0) {
+        return source.slice(start, index + 1);
+      }
+    }
+  }
+  return void 0;
+}
+function cleanJsonSource(source) {
+  const cleaned = source?.replace(/^<!--/, "").replace(/-->$/, "").trim();
+  return cleaned || void 0;
+}
+function dedupeEmbeddedItems(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const item of items) {
+    const key = `${item.source}:${item.path ?? ""}:${JSON.stringify(item.data).slice(0, 500)}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    unique.push(item);
+  }
+  return unique;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/extractors/jsonLd.ts
+function extractJsonLd(html) {
+  const $ = loadDocument(html);
+  const nodes = [];
+  const warnings = [];
+  $("script[type*='ld+json']").each((index, element) => {
+    const source = normalizeWhitespace($(element).text()) ?? normalizeWhitespace($(element).html());
+    if (!source) {
+      return;
+    }
+    try {
+      for (const node of flattenJsonLd(JSON.parse(cleanJson(source)))) {
+        nodes.push(node);
+      }
+    } catch (error) {
+      warnings.push(`Could not parse JSON-LD script at index ${index}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+  return { nodes, warnings };
+}
+function cleanJson(source) {
+  return source.replace(/^<!--/, "").replace(/-->$/, "").trim();
+}
+function flattenJsonLd(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => flattenJsonLd(item));
+  }
+  if (!isRecord2(value)) {
+    return [];
+  }
+  const graph = value["@graph"];
+  const current = value;
+  if (Array.isArray(graph)) {
+    return [current, ...graph.filter(isRecord2)];
+  }
+  return [current];
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/extractors/media.ts
+var LAZY_IMAGE_ATTRIBUTES = ["data-src", "data-original", "data-lazy-src", "data-image", "data-thumbnail"];
+var LAZY_MEDIA_ATTRIBUTES = ["data-src", "data-original", "data-lazy-src", "data-video", "data-media"];
+function extractImages(html, baseUrl) {
+  const $ = loadDocument(html);
+  const images = [];
+  $("link[rel='image_src'][href]").each((_, element) => {
+    pushResolved(images, {
+      url: normalizeWhitespace($(element).attr("href")),
+      kind: "image",
+      source: "html"
+    }, baseUrl);
+  });
+  $("link[rel][href]").each((_, element) => {
+    const relTokens = (normalizeWhitespace($(element).attr("rel"))?.toLowerCase() ?? "").split(/\s+/);
+    const asValue = normalizeWhitespace($(element).attr("as"))?.toLowerCase();
+    const type = normalizeWhitespace($(element).attr("type"));
+    if (!relTokens.includes("preload") && !relTokens.includes("prefetch")) {
+      return;
+    }
+    if (asValue === "image" || type?.startsWith("image/")) {
+      pushResolved(images, {
+        url: normalizeWhitespace($(element).attr("href")),
+        kind: "image",
+        source: "html",
+        type,
+        metadata: { discoveredFrom: "link.preload" }
+      }, baseUrl);
+    }
+  });
+  collectDocumentImages($, images, baseUrl, "html");
+  $("video[poster]").each((_, element) => {
+    pushResolved(images, {
+      url: normalizeWhitespace($(element).attr("poster")),
+      kind: "image",
+      source: "html",
+      width: parseInteger($(element).attr("width")),
+      height: parseInteger($(element).attr("height")),
+      metadata: {
+        discoveredFrom: "video.poster"
+      }
+    }, baseUrl);
+  });
+  $("noscript").each((_, element) => {
+    const fallbackHtml = $(element).html() || $(element).text();
+    if (!fallbackHtml) {
+      return;
+    }
+    collectDocumentImages(loadDocument(fallbackHtml), images, baseUrl, "fallback");
+  });
+  return uniqueMediaByUrl(images);
+}
+function extractVideos(html, baseUrl) {
+  const $ = loadDocument(html);
+  const videos = [];
+  $("video").each((_, element) => {
+    const src = normalizeWhitespace($(element).attr("src")) ?? firstAttribute($, element, LAZY_MEDIA_ATTRIBUTES);
+    const common = {
+      kind: "video",
+      source: "html",
+      width: parseInteger($(element).attr("width")),
+      height: parseInteger($(element).attr("height")),
+      poster: tryResolveUrl(normalizeWhitespace($(element).attr("poster")), baseUrl)
+    };
+    pushResolved(videos, { ...common, url: src }, baseUrl);
+    for (const attribute of LAZY_MEDIA_ATTRIBUTES) {
+      pushResolved(videos, {
+        ...common,
+        url: normalizeWhitespace($(element).attr(attribute))
+      }, baseUrl);
+    }
+    $(element).find("source[src]").each((_2, source) => {
+      pushResolved(videos, {
+        ...common,
+        url: normalizeWhitespace($(source).attr("src")),
+        type: normalizeWhitespace($(source).attr("type"))
+      }, baseUrl);
+    });
+  });
+  $("iframe[src]").each((_, element) => {
+    const src = normalizeWhitespace($(element).attr("src"));
+    if (!src || !isLikelyVideoEmbed(src)) {
+      return;
+    }
+    pushResolved(videos, {
+      url: src,
+      kind: "video",
+      source: "html",
+      width: parseInteger($(element).attr("width")),
+      height: parseInteger($(element).attr("height"))
+    }, baseUrl);
+  });
+  $("link[rel][href]").each((_, element) => {
+    const relTokens = (normalizeWhitespace($(element).attr("rel"))?.toLowerCase() ?? "").split(/\s+/);
+    const asValue = normalizeWhitespace($(element).attr("as"))?.toLowerCase();
+    const type = normalizeWhitespace($(element).attr("type"));
+    if (!relTokens.includes("preload") && !relTokens.includes("prefetch") || asValue !== "video" && !type?.startsWith("video/")) {
+      return;
+    }
+    pushResolved(videos, {
+      url: normalizeWhitespace($(element).attr("href")),
+      kind: "video",
+      source: "html",
+      type,
+      metadata: { discoveredFrom: "link.preload" }
+    }, baseUrl);
+  });
+  return uniqueMediaByUrl(videos);
+}
+function extractAudio(html, baseUrl) {
+  const $ = loadDocument(html);
+  const audio = [];
+  $("audio").each((_, element) => {
+    pushResolved(audio, {
+      url: normalizeWhitespace($(element).attr("src")),
+      kind: "audio",
+      source: "html"
+    }, baseUrl);
+    $(element).find("source[src]").each((_2, source) => {
+      pushResolved(audio, {
+        url: normalizeWhitespace($(source).attr("src")),
+        kind: "audio",
+        source: "html",
+        type: normalizeWhitespace($(source).attr("type"))
+      }, baseUrl);
+    });
+  });
+  return uniqueMediaByUrl(audio);
+}
+function pushResolved(assets, asset, baseUrl) {
+  const url = tryResolveUrl(asset.url, baseUrl);
+  if (!url || shouldIgnoreMediaUrl(url) || shouldIgnoreImageAsset(asset, url)) {
+    return;
+  }
+  assets.push({
+    ...asset,
+    url
+  });
+}
+function collectDocumentImages($, images, baseUrl, source) {
+  $("img").each((_, element) => {
+    const common = {
+      kind: "image",
+      source,
+      width: parseInteger($(element).attr("width")),
+      height: parseInteger($(element).attr("height")),
+      alt: normalizeWhitespace($(element).attr("alt")),
+      title: normalizeWhitespace($(element).attr("title"))
+    };
+    const candidates = [
+      normalizeWhitespace($(element).attr("src")),
+      ...LAZY_IMAGE_ATTRIBUTES.map((attribute) => normalizeWhitespace($(element).attr(attribute))),
+      ...parseSrcset($(element).attr("srcset"))
+    ];
+    for (const candidate of candidates) {
+      pushResolved(images, {
+        ...common,
+        url: candidate,
+        metadata: {
+          discoveredFrom: source === "fallback" ? "noscript" : "img"
+        }
+      }, baseUrl);
+    }
+  });
+  $("picture source[srcset], source[type^='image/'][srcset]").each((_, element) => {
+    for (const candidate of parseSrcset($(element).attr("srcset"))) {
+      pushResolved(images, {
+        url: candidate,
+        kind: "image",
+        source,
+        type: normalizeWhitespace($(element).attr("type")),
+        metadata: {
+          discoveredFrom: source === "fallback" ? "noscript.picture.source" : "picture.source"
+        }
+      }, baseUrl);
+    }
+  });
+}
+function shouldIgnoreMediaUrl(url) {
+  const normalized = url.toLowerCase();
+  return normalized.startsWith("data:") || normalized.startsWith("blob:") || normalized.startsWith("javascript:") || /(?:sprite|spacer|blank|transparent|placeholder|tracking|beacon|pixel)(?:[._/-]|$|\?)/i.test(normalized) || /(?:^|[/?_-])1x1(?:[._/-]|$|\?)/i.test(normalized);
+}
+function shouldIgnoreImageAsset(asset, url) {
+  if (asset.kind !== "image" && asset.kind !== "favicon") {
+    return false;
+  }
+  const width = asset.width;
+  const height = asset.height;
+  const normalizedUrl = url.toLowerCase();
+  if (width !== void 0 && height !== void 0) {
+    if (width <= 2 || height <= 2) {
+      return true;
+    }
+    if (width <= 64 && height <= 64 && /(?:icon|favicon|apple-touch-icon|sprite|logo|avatar)/i.test(normalizedUrl)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isLikelyVideoEmbed(src) {
+  return /youtube\.com|youtu\.be|vimeo\.com|dailymotion\.com|tiktok\.com|instagram\.com|facebook\.com|player\./i.test(src);
+}
+function firstAttribute($, element, attributes) {
+  for (const attribute of attributes) {
+    const value = normalizeWhitespace($(element).attr(attribute));
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// src/extractors/oEmbed.ts
+function extractOEmbed(html, url) {
+  const $ = loadDocument(html);
+  const links = [];
+  $("link[rel][href]").each((_, element) => {
+    const rel = normalizeWhitespace($(element).attr("rel"))?.toLowerCase() ?? "";
+    const relTokens = rel.split(/\s+/);
+    const type = normalizeWhitespace($(element).attr("type"));
+    const title = normalizeWhitespace($(element).attr("title"));
+    const hrefValue = normalizeWhitespace($(element).attr("href"));
+    const looksLikeOEmbed = /oembed/i.test(type ?? "") || /oembed/i.test(title ?? "") || /[?&]format=(?:json|xml)/i.test(hrefValue ?? "");
+    if (!relTokens.includes("alternate") && !relTokens.includes("alternate-oembed") && !looksLikeOEmbed) {
+      return;
+    }
+    if (!looksLikeOEmbed) {
+      return;
+    }
+    const href = tryResolveUrl(hrefValue, url);
+    if (!href) {
+      return;
+    }
+    links.push({
+      href,
+      type,
+      title
+    });
+  });
+  return {
+    links,
+    data: []
+  };
+}
+async function fetchOEmbedData(links, options = {}) {
+  const data = [];
+  const warnings = [];
+  await Promise.all(
+    links.map(async (link) => {
+      if (link.type && !/json/i.test(link.type)) {
+        warnings.push(`Skipping non-JSON oEmbed endpoint: ${link.href}.`);
+        return;
+      }
+      try {
+        const page = await fetchPage(link.href, {
+          ...options,
+          headers: {
+            "accept": "application/json,*/*;q=0.8",
+            ...headersToObject2(options.headers)
+          }
+        });
+        data.push(JSON.parse(page.html));
+      } catch (error) {
+        warnings.push(`Could not fetch oEmbed endpoint ${link.href}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    })
+  );
+  return { data, warnings };
+}
+function headersToObject2(headers) {
+  if (!headers) {
+    return {};
+  }
+  return Object.fromEntries(new Headers(headers).entries());
+}
+
+// src/extractors/openGraph.ts
+function extractOpenGraph(html) {
+  const $ = loadDocument(html);
+  const raw = {};
+  $("meta[property], meta[name]").each((_, element) => {
+    const key = readMetaKey($, element);
+    const content = normalizeWhitespace($(element).attr("content"));
+    if (!key || !content || !key.startsWith("og:") && !key.startsWith("article:") && !key.startsWith("product:")) {
+      return;
+    }
+    setMapValue(raw, key, content);
+  });
+  return {
+    title: firstRaw(raw, "og:title"),
+    description: firstRaw(raw, "og:description"),
+    type: firstRaw(raw, "og:type"),
+    url: firstRaw(raw, "og:url"),
+    siteName: firstRaw(raw, "og:site_name"),
+    locale: firstRaw(raw, "og:locale"),
+    determiner: firstRaw(raw, "og:determiner"),
+    images: collectStructuredMedia($, "image"),
+    videos: collectStructuredMedia($, "video"),
+    audio: collectStructuredMedia($, "audio"),
+    article: {
+      publishedTime: firstRaw(raw, "article:published_time"),
+      modifiedTime: firstRaw(raw, "article:modified_time"),
+      expirationTime: firstRaw(raw, "article:expiration_time"),
+      section: firstRaw(raw, "article:section"),
+      tags: allRaw(raw, "article:tag"),
+      authors: allRaw(raw, "article:author")?.map((name) => ({ name }))
+    },
+    product: {
+      price: firstRaw(raw, "product:price:amount"),
+      currency: firstRaw(raw, "product:price:currency"),
+      availability: firstRaw(raw, "product:availability"),
+      condition: firstRaw(raw, "product:condition")
+    },
+    raw
+  };
+}
+function collectStructuredMedia($, kind) {
+  const assets = [];
+  const prefix = `og:${kind}`;
+  $("meta[property], meta[name]").each((_, element) => {
+    const key = readMetaKey($, element);
+    const content = normalizeWhitespace($(element).attr("content"));
+    if (!key?.startsWith(prefix) || !content) {
+      return;
+    }
+    const current = assets.at(-1);
+    if (key === prefix || key === `${prefix}:url`) {
+      if (key.endsWith(":url") && current && !current.url) {
+        current.url = content;
+        return;
+      }
+      assets.push({
+        url: content,
+        kind,
+        source: "openGraph"
+      });
+      return;
+    }
+    const target = current ?? pushEmptyAsset(assets, kind);
+    const property = key.slice(prefix.length + 1);
+    if (property === "secure_url") {
+      target.secureUrl = content;
+    } else if (property === "type") {
+      target.type = content;
+    } else if (property === "width") {
+      target.width = parseInteger(content);
+    } else if (property === "height") {
+      target.height = parseInteger(content);
+    } else if (property === "alt") {
+      target.alt = content;
+    }
+  });
+  return assets.filter((asset) => Boolean(asset.url));
+}
+function pushEmptyAsset(assets, kind) {
+  const asset = {
+    url: "",
+    kind,
+    source: "openGraph"
+  };
+  assets.push(asset);
+  return asset;
+}
+function readMetaKey($, element) {
+  return normalizeWhitespace($(element).attr("property")) ?? normalizeWhitespace($(element).attr("name"));
+}
+function firstRaw(raw, key) {
+  const value = raw[key];
+  return Array.isArray(value) ? value[0] : value;
+}
+function allRaw(raw, key) {
+  const value = raw[key];
+  if (!value) {
+    return void 0;
+  }
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/extractors/twitter.ts
+function extractTwitterCards(html) {
+  const $ = loadDocument(html);
+  const raw = {};
+  $("meta[name], meta[property]").each((_, element) => {
+    const key = readMetaKey2($, element);
+    const content = normalizeWhitespace($(element).attr("content"));
+    if (!key?.startsWith("twitter:") || !content) {
+      return;
+    }
+    setMapValue(raw, key, content);
+  });
+  return {
+    card: firstRaw2(raw, "twitter:card"),
+    site: firstRaw2(raw, "twitter:site"),
+    creator: firstRaw2(raw, "twitter:creator"),
+    title: firstRaw2(raw, "twitter:title"),
+    description: firstRaw2(raw, "twitter:description"),
+    images: collectImages(raw),
+    videos: collectVideos(raw),
+    raw
+  };
+}
+function collectImages(raw) {
+  const urls = uniqueStrings([
+    ...allRaw2(raw, "twitter:image"),
+    ...allRaw2(raw, "twitter:image:src"),
+    ...allRaw2(raw, "twitter:images"),
+    ...allRaw2(raw, "twitter:image0"),
+    ...allRaw2(raw, "twitter:image1"),
+    ...allRaw2(raw, "twitter:image2"),
+    ...allRaw2(raw, "twitter:image3"),
+    ...allRaw2(raw, "twitter:player:image"),
+    ...Object.entries(raw).filter(([key]) => /^twitter:image(?::\d+)?$/i.test(key) || /^twitter:image:\d+$/i.test(key)).flatMap(([, value]) => Array.isArray(value) ? value : [value])
+  ]);
+  const alt = firstRaw2(raw, "twitter:image:alt");
+  const width = parseInteger(firstRaw2(raw, "twitter:image:width"));
+  const height = parseInteger(firstRaw2(raw, "twitter:image:height"));
+  return urls.map((url) => ({
+    url,
+    kind: "image",
+    source: "twitter",
+    alt,
+    width,
+    height
+  }));
+}
+function collectVideos(raw) {
+  const players = allRaw2(raw, "twitter:player") ?? allRaw2(raw, "twitter:player:stream") ?? [];
+  const width = parseInteger(firstRaw2(raw, "twitter:player:width"));
+  const height = parseInteger(firstRaw2(raw, "twitter:player:height"));
+  return players.map((url) => ({
+    url,
+    kind: "video",
+    source: "twitter",
+    width,
+    height
+  }));
+}
+function readMetaKey2($, element) {
+  return normalizeWhitespace($(element).attr("name")) ?? normalizeWhitespace($(element).attr("property"));
+}
+function firstRaw2(raw, key) {
+  const value = raw[key];
+  return Array.isArray(value) ? value[0] : value;
+}
+function allRaw2(raw, key) {
+  const value = raw[key];
+  if (!value) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+// src/scorers/image.ts
+var SOURCE_WEIGHT = {
+  adapter: 96,
+  openGraph: 92,
+  oEmbed: 88,
+  jsonLd: 82,
+  twitter: 78,
+  nextData: 76,
+  nuxt: 74,
+  initialState: 73,
+  preloadedState: 73,
+  apollo: 72,
+  applicationJson: 70,
+  jsonScript: 66,
+  html: 42,
+  fallback: 36,
+  favicon: 8
+};
+function scoreImages(images, customScorers = []) {
+  const duplicateCounts = countDuplicates(images);
+  return images.map((image, index) => {
+    const scored = scoreImageWithDetails(image, index, images, duplicateCounts);
+    const customScore = customScorers.reduce((total, scorer) => total + scorer(image, { index, images }), 0);
+    const score = clamp(scored.score + customScore, 0, 100);
+    const reasons = customScore === 0 ? scored.reasons : [...scored.reasons, `custom scorers adjusted score by ${formatSigned(customScore)}`];
+    return {
+      ...image,
+      score,
+      confidence: Number((score / 100).toFixed(2)),
+      metadata: {
+        ...image.metadata,
+        scoreReasons: reasons
+      }
+    };
+  }).sort((left, right) => (right.score ?? 0) - (left.score ?? 0));
+}
+function selectBestImage(images, customScorers = []) {
+  const scored = scoreImages(images, customScorers);
+  const best = scored[0];
+  return {
+    best,
+    images: scored,
+    reason: best ? explainImageChoice(best) : void 0
+  };
+}
+function scoreImageWithDetails(image, index, images, duplicateCounts) {
+  let score = SOURCE_WEIGHT[image.source] ?? 50;
+  const reasons = [`source ${sourceLabel(image.source)} added ${score} base points`];
+  const dimensions = scoreDimensions(image);
+  const format = scoreFormat(image);
+  const urlSignal = scoreUrlSignal(image);
+  const urlPenalty = scoreUrlPenalty(image);
+  const duplicatePenalty = scoreDuplicatePenalty(image, duplicateCounts);
+  score += dimensions.score;
+  score += format.score;
+  score += urlSignal.score;
+  score -= urlPenalty;
+  score -= duplicatePenalty.score;
+  score -= Math.min(index * 1.5, 10);
+  reasons.push(...dimensions.reasons, ...format.reasons, ...urlSignal.reasons, ...duplicatePenalty.reasons);
+  if (images.length === 1) {
+    score += 4;
+    reasons.push("only candidate image added 4 points");
+  }
+  if (urlPenalty > 0) {
+    reasons.push(`URL penalties subtracted ${urlPenalty} points`);
+  }
+  const positionPenalty = Math.min(index * 1.5, 10);
+  if (positionPenalty > 0) {
+    reasons.push(`candidate position subtracted ${formatNumber(positionPenalty)} points`);
+  }
+  return { score, reasons };
+}
+function scoreDimensions(image) {
+  const width = image.width;
+  const height = image.height;
+  if (!width || !height) {
+    return { score: 0, reasons: ["dimensions are unknown"] };
+  }
+  const area = width * height;
+  const ratio = width / height;
+  let score = 0;
+  const reasons = [];
+  if (width < 120 || height < 90) {
+    score -= 35;
+    reasons.push(`${width}x${height} is below preview minimum and subtracted 35 points`);
+  } else if (area >= 1e6) {
+    score += 12;
+    reasons.push(`${width}x${height} dimensions added 12 points`);
+  } else if (area >= 3e5) {
+    score += 9;
+    reasons.push(`${width}x${height} dimensions added 9 points`);
+  } else if (area >= 9e4) {
+    score += 5;
+    reasons.push(`${width}x${height} dimensions added 5 points`);
+  } else if (area < 1e4) {
+    score -= 20;
+    reasons.push(`${width}x${height} dimensions subtracted 20 points`);
+  }
+  if (isNear(ratio, 1.91, 0.18)) {
+    score += 12;
+    reasons.push(`aspect ratio ${ratio.toFixed(2)} matched social preview ratio`);
+  } else if (isNear(ratio, 16 / 9, 0.2) || isNear(ratio, 1, 0.2)) {
+    score += 8;
+    reasons.push(`aspect ratio ${ratio.toFixed(2)} matched a common preview ratio`);
+  } else if (ratio > 4 || ratio < 0.25) {
+    score -= 16;
+    reasons.push(`aspect ratio ${ratio.toFixed(2)} is unlikely to preview well`);
+  }
+  return { score, reasons };
+}
+function scoreFormat(image) {
+  const type = image.type?.toLowerCase() ?? "";
+  const url = image.url.toLowerCase();
+  if (type.includes("webp") || url.endsWith(".webp")) {
+    return { score: 4, reasons: ["modern WebP format added 4 points"] };
+  }
+  if (type.includes("avif") || /\.(avif)(\?|$)/.test(url)) {
+    return { score: 4, reasons: ["modern AVIF format added 4 points"] };
+  }
+  if (type.includes("jpeg") || type.includes("jpg") || /\.(jpe?g)(\?|$)/.test(url)) {
+    return { score: 3, reasons: ["JPEG format added 3 points"] };
+  }
+  if (type.includes("png") || /\.(png)(\?|$)/.test(url)) {
+    return { score: 2, reasons: ["PNG format added 2 points"] };
+  }
+  if (/\.(gif|svg|ico)(\?|$)/.test(url)) {
+    return { score: -8, reasons: ["GIF/SVG/ICO formats are weaker preview candidates"] };
+  }
+  return { score: 0, reasons: [] };
+}
+function scoreUrlSignal(image) {
+  const url = image.url.toLowerCase();
+  const matches = url.match(/cover|preview|thumbnail|thumb|og|card|media|hero|share|social/g) ?? [];
+  if (matches.length === 0) {
+    return { score: 0, reasons: [] };
+  }
+  const uniqueMatches = [...new Set(matches)];
+  const score = Math.min(uniqueMatches.length * 4, 12);
+  return {
+    score,
+    reasons: [`URL matched preview hints (${uniqueMatches.join(", ")}) and added ${score} points`]
+  };
+}
+function scoreUrlPenalty(image) {
+  const url = image.url.toLowerCase();
+  let penalty = 0;
+  if (/favicon|apple-touch-icon|sprite|icon-|\/icon|placeholder|blank|spacer|pixel|tracking|emoji/.test(url)) {
+    penalty += 30;
+  }
+  if (/logo|avatar|profile|headshot|badge/.test(url)) {
+    penalty += 22;
+  }
+  if (image.alt && /logo|avatar|icon|emoji/i.test(image.alt)) {
+    penalty += 14;
+  }
+  if (image.kind === "favicon") {
+    penalty += 35;
+  }
+  return penalty;
+}
+function scoreDuplicatePenalty(image, duplicateCounts) {
+  const count = duplicateCounts.get(mediaSignature(image.url)) ?? 0;
+  if (count <= 1) {
+    return { score: 0, reasons: [] };
+  }
+  const penalty = Math.min((count - 1) * 4, 12);
+  return {
+    score: penalty,
+    reasons: [`duplicate-like URL group subtracted ${penalty} points`]
+  };
+}
+function explainImageChoice(image) {
+  const dimensions = image.width && image.height ? `${image.width}x${image.height}` : "unknown dimensions";
+  const reasons = Array.isArray(image.metadata?.scoreReasons) ? image.metadata.scoreReasons.slice(0, 4).join("; ") : "";
+  const reasonSuffix = reasons ? ` Reasons: ${reasons}.` : "";
+  return `Selected because it came from ${sourceLabel(image.source)}, has ${dimensions}, and scored ${Math.round(image.score ?? 0)}.${reasonSuffix}`;
+}
+function isNear(value, target, tolerance) {
+  return Math.abs(value - target) <= tolerance;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function sourceLabel(source) {
+  if (source === "openGraph") {
+    return "og:image";
+  }
+  if (source === "twitter") {
+    return "Twitter Card metadata";
+  }
+  if (source === "jsonLd") {
+    return "JSON-LD";
+  }
+  if (source === "oEmbed") {
+    return "oEmbed";
+  }
+  if (["nextData", "nuxt", "initialState", "preloadedState", "apollo", "applicationJson", "jsonScript"].includes(source)) {
+    return "embedded application data";
+  }
+  return source;
+}
+function formatSigned(value) {
+  return value >= 0 ? `+${formatNumber(value)}` : formatNumber(value);
+}
+function formatNumber(value) {
+  return Number.isInteger(value) ? String(value) : value.toFixed(1);
+}
+function countDuplicates(images) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const image of images) {
+    const key = mediaSignature(image.url);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function mediaSignature(url) {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.hostname.toLowerCase()}${parsed.pathname.replace(/[-_](?:\d{2,5}x\d{2,5}|\d{2,5}w|small|medium|large|thumb|thumbnail)(?=\.)/i, "").toLowerCase()}`;
+  } catch {
+    return url.toLowerCase();
+  }
+}
+
+// src/media/MediaDiscoveryEngine.ts
+var IMAGE_KEYS = [
+  "image",
+  "images",
+  "thumbnail",
+  "thumbnailUrl",
+  "thumbnail_url",
+  "thumbnailSrc",
+  "previewImage",
+  "preview_image",
+  "ogImage",
+  "cardImage",
+  "cover",
+  "coverImage",
+  "poster",
+  "media"
+];
+var VIDEO_KEYS = ["video", "videos", "videoUrl", "video_url", "contentUrl", "embedUrl", "playbackUrl"];
+var AUDIO_KEYS = ["audio", "audios", "audioUrl", "audio_url", "podcastUrl"];
+function discoverMedia(rawSources, finalUrl) {
+  const trace = [];
+  const externalResults = [...rawSources.plugins, ...rawSources.adapters];
+  const images = normalizeAssets(
+    [
+      ...externalResults.flatMap((result) => result.images ?? []),
+      ...rawSources.openGraph.images,
+      ...rawSources.twitter.images,
+      ...jsonLdImages(rawSources.jsonLd.nodes),
+      ...embeddedImages(rawSources.embeddedData.items),
+      ...rawSources.html.imageSrc ? [rawSources.html.imageSrc] : [],
+      ...rawSources.images,
+      ...oEmbedImages(rawSources)
+    ],
+    finalUrl
+  );
+  const videos = normalizeAssets(
+    [
+      ...externalResults.flatMap((result) => result.videos ?? []),
+      ...rawSources.openGraph.videos,
+      ...rawSources.twitter.videos,
+      ...jsonLdVideos(rawSources.jsonLd.nodes),
+      ...embeddedVideos(rawSources.embeddedData.items),
+      ...rawSources.videos
+    ],
+    finalUrl
+  );
+  const audio = normalizeAssets(
+    [
+      ...externalResults.flatMap((result) => result.audio ?? []),
+      ...rawSources.openGraph.audio,
+      ...jsonLdAudio(rawSources.jsonLd.nodes),
+      ...embeddedAudio(rawSources.embeddedData.items),
+      ...rawSources.audio
+    ],
+    finalUrl
+  );
+  if (rawSources.openGraph.images.length > 0) {
+    trace.push("media discovery collected og:image candidates");
+  }
+  if (rawSources.twitter.images.length > 0) {
+    trace.push("media discovery collected twitter:image candidates");
+  }
+  if (rawSources.jsonLd.nodes.length > 0) {
+    trace.push("media discovery scanned JSON-LD media");
+  }
+  if (rawSources.embeddedData.items.length > 0) {
+    trace.push("media discovery scanned embedded application data");
+  }
+  if (rawSources.images.length > 0) {
+    trace.push("media discovery scanned HTML images, srcset, lazy images, posters, and fallbacks");
+  }
+  if (externalResults.some((result) => (result.images?.length ?? 0) > 0 || (result.videos?.length ?? 0) > 0)) {
+    trace.push("media discovery included adapter and plugin media");
+  }
+  return {
+    images: dedupeMediaBySignature(uniqueMediaByUrl(images)),
+    videos: dedupeMediaBySignature(uniqueMediaByUrl(videos)),
+    audio: dedupeMediaBySignature(uniqueMediaByUrl(audio)),
+    trace
+  };
+}
+function normalizeAssets(assets, baseUrl) {
+  return assets.map((asset) => {
+    const secureUrl = tryResolveUrl(asset.secureUrl, baseUrl);
+    const url = tryResolveUrl(secureUrl ?? asset.url, baseUrl);
+    const poster = tryResolveUrl(asset.poster, baseUrl);
+    if (!url || shouldIgnoreMediaUrl2(url)) {
+      return void 0;
+    }
+    return stripUndefined({
+      ...asset,
+      url,
+      secureUrl,
+      poster
+    });
+  }).filter((asset) => Boolean(asset));
+}
+function jsonLdImages(nodes) {
+  return nodes.flatMap((node) => [
+    ...mediaFromJsonValue(node.image, "image", "jsonLd"),
+    ...mediaFromJsonValue(node.thumbnailUrl, "image", "jsonLd"),
+    ...mediaFromJsonValue(node.thumbnail, "image", "jsonLd"),
+    ...mediaFromJsonValue(node.logo, "image", "jsonLd")
+  ]);
+}
+function jsonLdVideos(nodes) {
+  return nodes.flatMap((node) => [
+    ...mediaFromJsonValue(node.contentUrl, "video", "jsonLd"),
+    ...mediaFromJsonValue(node.embedUrl, "video", "jsonLd"),
+    ...mediaFromJsonValue(node.video, "video", "jsonLd")
+  ]);
+}
+function jsonLdAudio(nodes) {
+  return nodes.flatMap((node) => [
+    ...mediaFromJsonValue(node.contentUrl, "audio", "jsonLd"),
+    ...mediaFromJsonValue(node.encoding, "audio", "jsonLd")
+  ]);
+}
+function embeddedImages(items) {
+  return items.flatMap((item) => mediaFromEmbeddedItem(item, IMAGE_KEYS, "image"));
+}
+function embeddedVideos(items) {
+  return items.flatMap((item) => mediaFromEmbeddedItem(item, VIDEO_KEYS, "video"));
+}
+function embeddedAudio(items) {
+  return items.flatMap((item) => mediaFromEmbeddedItem(item, AUDIO_KEYS, "audio"));
+}
+function mediaFromEmbeddedItem(item, keys, kind) {
+  const assets = [];
+  walkEmbeddedData(item.data, (value, key, parent) => {
+    if (!key || !keys.some((candidate) => candidate.toLowerCase() === key.toLowerCase())) {
+      if (typeof value === "string" && looksLikeMediaUrl(value, kind) && key && keys.some((candidate) => key.toLowerCase().includes(candidate.toLowerCase()))) {
+        assets.push(assetFromEmbedded(value, kind, item, parent));
+      }
+      return;
+    }
+    assets.push(...mediaFromJsonValue(value, kind, item.source));
+  });
+  return assets;
+}
+function mediaFromJsonValue(value, kind, source) {
+  if (!value) {
+    return [];
+  }
+  if (typeof value === "string") {
+    return looksLikeMediaUrl(value, kind) ? [{ url: value, kind, source }] : [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => mediaFromJsonValue(item, kind, source));
+  }
+  if (isRecord3(value)) {
+    const url = stringFromUnknown(value.url) ?? stringFromUnknown(value.src) ?? stringFromUnknown(value.contentUrl) ?? stringFromUnknown(value.thumbnailUrl);
+    if (!url || !looksLikeMediaUrl(url, kind)) {
+      return [];
+    }
+    return [
+      {
+        url,
+        kind,
+        source,
+        width: parseNumber(stringFromUnknown(value.width)),
+        height: parseNumber(stringFromUnknown(value.height)),
+        alt: stringFromUnknown(value.alt) ?? stringFromUnknown(value.caption) ?? stringFromUnknown(value.name),
+        title: stringFromUnknown(value.title),
+        type: stringFromUnknown(value.type) ?? stringFromUnknown(value.mimeType) ?? stringFromUnknown(value.encodingFormat)
+      }
+    ];
+  }
+  return [];
+}
+function assetFromEmbedded(value, kind, item, parent) {
+  return {
+    url: value,
+    kind,
+    source: item.source,
+    width: parseNumber(stringFromUnknown(parent?.width)),
+    height: parseNumber(stringFromUnknown(parent?.height)),
+    alt: stringFromUnknown(parent?.alt) ?? stringFromUnknown(parent?.caption),
+    title: stringFromUnknown(parent?.title),
+    metadata: {
+      embeddedPath: item.path
+    }
+  };
+}
+function oEmbedImages(rawSources) {
+  return rawSources.oEmbed.data.flatMap((data) => {
+    const images = [];
+    if (data.thumbnail_url) {
+      images.push({
+        url: data.thumbnail_url,
+        kind: "image",
+        source: "oEmbed",
+        width: data.thumbnail_width,
+        height: data.thumbnail_height
+      });
+    }
+    if (data.type === "photo" && data.url) {
+      images.push({
+        url: data.url,
+        kind: "image",
+        source: "oEmbed",
+        width: data.width,
+        height: data.height
+      });
+    }
+    return images;
+  });
+}
+function dedupeMediaBySignature(assets) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    const key = mediaSignature2(asset.url);
+    const current = seen.get(key);
+    if (!current || sourceRank(asset.source) > sourceRank(current.source)) {
+      seen.set(key, asset);
+    }
+  }
+  return [...seen.values()];
+}
+function mediaSignature2(url) {
+  try {
+    const parsed = new URL(url);
+    const pathname = parsed.pathname.replace(/[-_](?:\d{2,5}x\d{2,5}|\d{2,5}w|small|medium|large|thumb|thumbnail)(?=\.)/i, "").toLowerCase();
+    return `${parsed.hostname.toLowerCase()}${pathname}`;
+  } catch {
+    return url.toLowerCase();
+  }
+}
+function sourceRank(source) {
+  const ranks = {
+    adapter: 90,
+    openGraph: 80,
+    twitter: 75,
+    jsonLd: 70,
+    oEmbed: 65,
+    nextData: 64,
+    nuxt: 62,
+    initialState: 61,
+    preloadedState: 60,
+    apollo: 59,
+    applicationJson: 58,
+    jsonScript: 55,
+    html: 40,
+    fallback: 30
+  };
+  return ranks[source] ?? 50;
+}
+function shouldIgnoreMediaUrl2(url) {
+  const normalized = url.toLowerCase();
+  return normalized.startsWith("data:") || normalized.startsWith("blob:") || normalized.startsWith("javascript:") || /(?:sprite|spacer|blank|transparent|placeholder|tracking|beacon|pixel|emoji)(?:[._/-]|$|\?)/i.test(normalized) || /(?:^|[/?_-])1x1(?:[._/-]|$|\?)/i.test(normalized);
+}
+function looksLikeMediaUrl(value, kind) {
+  if (shouldIgnoreMediaUrl2(value)) {
+    return false;
+  }
+  if (/^https?:\/\//i.test(value) || value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) {
+    if (kind === "image") {
+      return /\.(?:avif|webp|png|jpe?g|gif)(?:[?#].*)?$/i.test(value) || /(?:image|thumb|thumbnail|cover|poster|preview|media|og|card|photo)/i.test(value);
+    }
+    if (kind === "video") {
+      return /\.(?:mp4|webm|m3u8|mov)(?:[?#].*)?$/i.test(value) || /(?:video|embed|player|watch|reel|shorts)/i.test(value);
+    }
+    if (kind === "audio") {
+      return /\.(?:mp3|m4a|wav|ogg|aac)(?:[?#].*)?$/i.test(value) || /(?:audio|podcast)/i.test(value);
+    }
+  }
+  return false;
+}
+function walkEmbeddedData(value, visit, key, parent, depth = 0) {
+  if (depth > 8) {
+    return;
+  }
+  visit(value, key, parent);
+  if (Array.isArray(value)) {
+    for (const item of value.slice(0, 250)) {
+      walkEmbeddedData(item, visit, void 0, parent, depth + 1);
+    }
+    return;
+  }
+  if (isRecord3(value)) {
+    for (const [childKey, childValue] of Object.entries(value).slice(0, 500)) {
+      walkEmbeddedData(childValue, visit, childKey, value, depth + 1);
+    }
+  }
+}
+function stripUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0 && item !== null && (!Array.isArray(item) || item.length > 0)));
+}
+function stringFromUnknown(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (isRecord3(value)) {
+    return stringFromUnknown(value.url) ?? stringFromUnknown(value.src) ?? stringFromUnknown(value.name);
+  }
+  return void 0;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/engines/ConfidenceEngine.ts
+function calculateConfidence(input) {
+  let score = 0;
+  score += qualityPoints(input.title, 18, 6, 120);
+  score += qualityPoints(input.description, 16, 24, 300);
+  if (input.bestImage) {
+    score += 18;
+    score += Math.min(input.bestImage.score ?? 0, 100) * 0.12;
+    score += sourceConfidenceBonus(input.bestImage.source);
+  }
+  if (input.canonicalUrl) {
+    score += 10;
+  }
+  if (input.hasStructuredData) {
+    score += 12;
+  }
+  if (adapterSucceeded(input.rawSources.adapters)) {
+    score += 8;
+  }
+  if (input.sourcesUsed.includes("openGraph")) {
+    score += 6;
+  }
+  if (input.sourcesUsed.includes("twitter")) {
+    score += 4;
+  }
+  if (input.rawSources.embeddedData.items.length > 0) {
+    score += 6;
+  }
+  score -= Math.min(input.warnings.length * 3, 18);
+  return Math.round(clamp2(score, 0, 100));
+}
+function calculateCompleteness(input) {
+  const weights = [
+    input.title ? 20 : 0,
+    input.description ? 16 : 0,
+    input.bestImage ? 20 : 0,
+    input.canonicalUrl ? 12 : 0,
+    input.siteName ? 8 : 0,
+    input.author ? 8 : 0,
+    input.publisher ? 5 : 0,
+    input.type && input.type !== "unknown" ? 6 : 0,
+    input.publishedTime ? 3 : 0,
+    input.mediaCount > 1 ? 2 : 0
+  ];
+  return Math.round(clamp2(weights.reduce((total, value) => total + value, 0), 0, 100));
+}
+function calculateReliability(input) {
+  let score = input.confidence * 0.45 + input.completeness * 0.3;
+  if (input.adapterMatched) {
+    score += 10;
+  }
+  if ((input.bestImage?.score ?? 0) >= 80) {
+    score += 10;
+  } else if (input.bestImage) {
+    score += 5;
+  }
+  score -= Math.min(input.warnings.length * 4, 20);
+  return Math.round(clamp2(score, 0, 100));
+}
+function qualityPoints(value, maxPoints, idealMinLength, idealMaxLength) {
+  if (!value) {
+    return 0;
+  }
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return 0;
+  }
+  let points = maxPoints;
+  if (normalized.length < idealMinLength) {
+    points *= normalized.length / idealMinLength;
+  }
+  if (normalized.length > idealMaxLength) {
+    points *= Math.max(0.4, idealMaxLength / normalized.length);
+  }
+  if (/^(home|untitled|index|login|sign in)$/i.test(normalized)) {
+    points *= 0.35;
+  }
+  return points;
+}
+function sourceConfidenceBonus(source) {
+  if (source === "adapter") {
+    return 8;
+  }
+  if (source === "openGraph" || source === "twitter") {
+    return 7;
+  }
+  if (source === "jsonLd" || source === "oEmbed") {
+    return 6;
+  }
+  if (["nextData", "nuxt", "initialState", "preloadedState", "apollo", "applicationJson"].includes(source)) {
+    return 5;
+  }
+  if (source === "html") {
+    return 3;
+  }
+  return 1;
+}
+function adapterSucceeded(adapters) {
+  return adapters.some((adapter) => Boolean(adapter.title || adapter.description || adapter.images?.length || adapter.videos?.length));
+}
+function clamp2(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// src/normalizers/normalize.ts
+function normalizeMetadata(rawSources, context = {}) {
+  const finalUrl = context.finalUrl ?? context.url ?? "";
+  const url = context.url ?? finalUrl;
+  const externalResults = [...rawSources.plugins, ...rawSources.adapters];
+  const jsonLdNodes = rawSources.jsonLd.nodes;
+  const embeddedNodes = rawSources.embeddedData.items.map((item) => item.data);
+  const articleNode = findJsonLdNode(jsonLdNodes, ["Article", "NewsArticle", "BlogPosting"]);
+  const productNode = findJsonLdNode(jsonLdNodes, ["Product"]);
+  const appNode = findJsonLdNode(jsonLdNodes, ["SoftwareApplication", "MobileApplication", "WebApplication"]);
+  const organizationNode = findJsonLdNode(jsonLdNodes, ["Organization", "NewsMediaOrganization", "WebSite"]);
+  const canonicalUrl = tryResolveUrl(
+    firstDefined(
+      firstResultValue(externalResults, (result) => result.canonicalUrl),
+      rawSources.html.canonicalUrl,
+      rawSources.openGraph.url,
+      jsonString(jsonLdNodes, "url"),
+      findStringByKeys(embeddedNodes, ["canonicalUrl", "canonical", "permalink", "pageUrl", "shareUrl"])
+    ),
+    finalUrl
+  );
+  const title = firstDefined(
+    firstResultValue(externalResults, (result) => result.title),
+    rawSources.openGraph.title,
+    rawSources.twitter.title,
+    jsonString([articleNode, productNode, appNode, organizationNode].filter(isJsonLdNode), "headline"),
+    jsonString([articleNode, productNode, appNode, organizationNode].filter(isJsonLdNode), "name"),
+    findStringByKeys(embeddedNodes, ["title", "headline", "pageTitle", "ogTitle", "name"]),
+    rawSources.html.title
+  );
+  const description = firstDefined(
+    firstResultValue(externalResults, (result) => result.description),
+    rawSources.openGraph.description,
+    rawSources.twitter.description,
+    jsonString([articleNode, productNode, appNode, organizationNode].filter(isJsonLdNode), "description"),
+    findStringByKeys(embeddedNodes, ["description", "excerpt", "summary", "subtitle", "ogDescription"]),
+    rawSources.html.description
+  );
+  const siteName = firstDefined(
+    firstResultValue(externalResults, (result) => result.siteName),
+    rawSources.openGraph.siteName,
+    jsonString([organizationNode].filter(isJsonLdNode), "name"),
+    findStringByKeys(embeddedNodes, ["siteName", "site_name", "appName", "applicationName"]),
+    domainName(finalUrl)
+  );
+  const mediaDiscovery = discoverMedia(rawSources, finalUrl);
+  const images = mediaDiscovery.images;
+  const videos = mediaDiscovery.videos;
+  const audio = mediaDiscovery.audio;
+  const favicons = normalizeAssets2(rawSources.html.favicons, finalUrl);
+  const selectedImage = selectBestImage(images, context.imageScorers);
+  const article = mergeArticle(rawSources, externalResults, articleNode, embeddedNodes);
+  const product = mergeProduct(rawSources, externalResults, productNode);
+  const app = mergeApp(rawSources, externalResults, appNode);
+  const video = mergeVideo(rawSources, externalResults, jsonLdNodes, embeddedNodes, videos);
+  const playlist = mergePlaylist(externalResults);
+  const type = inferType(rawSources, externalResults, jsonLdNodes, article, product, app, playlist, videos, audio);
+  const author = firstResultValue(externalResults, (result) => result.author) ?? firstEntity(article?.authors) ?? entityFromEmbedded(embeddedNodes, ["author", "creator", "owner", "user"]);
+  const publisher = article?.publisher ?? firstResultValue(externalResults, (result) => result.publisher) ?? entityFromJsonLd(organizationNode) ?? entityFromEmbedded(embeddedNodes, ["publisher", "provider", "organization"]);
+  const sourcesUsed = detectSourcesUsed(rawSources);
+  const warnings = diagnosticsWarnings(rawSources, externalResults, context.diagnostics);
+  const fieldSources = {
+    title: fieldSource(rawSources, externalResults, embeddedNodes, "title", selectedImage.best),
+    description: fieldSource(rawSources, externalResults, embeddedNodes, "description", selectedImage.best),
+    author: fieldSource(rawSources, externalResults, embeddedNodes, "author", selectedImage.best),
+    image: fieldSource(rawSources, externalResults, embeddedNodes, "image", selectedImage.best)
+  };
+  const confidence = calculateConfidence({
+    title,
+    description,
+    bestImage: selectedImage.best,
+    canonicalUrl,
+    hasStructuredData: jsonLdNodes.length > 0,
+    rawSources,
+    sourcesUsed,
+    warnings
+  });
+  const completeness = calculateCompleteness({
+    title,
+    description,
+    bestImage: selectedImage.best,
+    canonicalUrl,
+    siteName,
+    author,
+    publisher,
+    type,
+    publishedTime: article?.publishedTime,
+    mediaCount: images.length + videos.length + audio.length
+  });
+  const reliability = calculateReliability({
+    confidence,
+    completeness,
+    adapterMatched: rawSources.adapters.length > 0,
+    bestImage: selectedImage.best,
+    warnings
+  });
+  const diagnostics = context.diagnostics ?? {
+    redirects: [],
+    sourcesUsed: [],
+    warnings: [],
+    trace: [],
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  diagnostics.sourcesUsed = uniqueStrings2([...diagnostics.sourcesUsed, ...sourcesUsed]);
+  diagnostics.warnings = uniqueStrings2([...diagnostics.warnings, ...rawSources.jsonLd.warnings, ...externalResults.flatMap((result) => result.warnings ?? [])]);
+  diagnostics.selectedImageReason = selectedImage.reason;
+  diagnostics.originalUrl = diagnostics.originalUrl ?? url;
+  diagnostics.finalUrl = diagnostics.finalUrl ?? finalUrl;
+  diagnostics.canonicalUrl = canonicalUrl;
+  diagnostics.adapter = adapterDiagnostics(rawSources.adapters);
+  diagnostics.trace = uniqueStrings2([
+    ...diagnostics.trace,
+    ...mediaDiscovery.trace,
+    ...selectedImage.best ? [`selected image from ${sourceLabel2(selectedImage.best)}`] : []
+  ]);
+  return stripUndefined2({
+    ok: true,
+    url,
+    finalUrl,
+    type,
+    title,
+    description,
+    siteName,
+    canonicalUrl,
+    confidence,
+    completeness,
+    reliability,
+    bestImage: selectedImage.best?.url,
+    images: selectedImage.images,
+    videos,
+    audio,
+    favicons,
+    article,
+    product,
+    video,
+    playlist,
+    author,
+    publisher,
+    app,
+    sources: fieldSources,
+    raw: context.includeRaw ? rawSources : void 0,
+    diagnostics,
+    trace: diagnostics.trace
+  });
+}
+function normalizeAssets2(assets, baseUrl) {
+  return assets.map((asset) => {
+    const secureUrl = tryResolveUrl(asset.secureUrl, baseUrl);
+    const url = tryResolveUrl(secureUrl ?? asset.url, baseUrl);
+    const poster = tryResolveUrl(asset.poster, baseUrl);
+    if (!url) {
+      return void 0;
+    }
+    return stripUndefined2({
+      ...asset,
+      url,
+      secureUrl,
+      poster
+    });
+  }).filter((asset) => Boolean(asset));
+}
+function mergeArticle(rawSources, externalResults, articleNode, embeddedNodes) {
+  const embeddedAuthor = entityFromEmbedded(embeddedNodes, ["author", "creator", "owner", "user"]);
+  const embeddedPublisher = entityFromEmbedded(embeddedNodes, ["publisher", "provider", "organization"]);
+  const article = {
+    ...rawSources.openGraph.article,
+    ...mergePartialObjects(externalResults.map((result) => result.article)),
+    headline: firstDefined(
+      firstResultValue(externalResults, (result) => result.article?.headline),
+      jsonString([articleNode].filter(isJsonLdNode), "headline"),
+      findStringByKeys(embeddedNodes, ["headline", "title", "postTitle", "pinTitle", "projectTitle"]),
+      rawSources.openGraph.article?.headline,
+      rawSources.openGraph.title
+    ),
+    section: firstDefined(
+      firstResultValue(externalResults, (result) => result.article?.section),
+      rawSources.openGraph.article?.section,
+      jsonString([articleNode].filter(isJsonLdNode), "articleSection")
+    ),
+    publishedTime: firstDefined(
+      firstResultValue(externalResults, (result) => result.article?.publishedTime),
+      rawSources.openGraph.article?.publishedTime,
+      jsonString([articleNode].filter(isJsonLdNode), "datePublished"),
+      findStringByKeys(embeddedNodes, ["datePublished", "publishedTime", "published_at", "createdAt", "created_at", "timestamp"])
+    ),
+    modifiedTime: firstDefined(
+      firstResultValue(externalResults, (result) => result.article?.modifiedTime),
+      rawSources.openGraph.article?.modifiedTime,
+      jsonString([articleNode].filter(isJsonLdNode), "dateModified")
+    ),
+    expirationTime: firstDefined(
+      firstResultValue(externalResults, (result) => result.article?.expirationTime),
+      rawSources.openGraph.article?.expirationTime
+    ),
+    tags: uniqueStrings2([
+      ...rawSources.openGraph.article?.tags ?? [],
+      ...jsonKeywords(articleNode)
+    ]),
+    authors: firstDefined(
+      firstResultValue(externalResults, (result) => result.article?.authors),
+      rawSources.openGraph.article?.authors,
+      entitiesFromJsonLd(articleNode?.author),
+      embeddedAuthor ? [embeddedAuthor] : void 0
+    ),
+    publisher: firstDefined(
+      firstResultValue(externalResults, (result) => result.article?.publisher),
+      rawSources.openGraph.article?.publisher,
+      entityFromJsonLd(articleNode?.publisher),
+      embeddedPublisher
+    )
+  };
+  return emptyToUndefined(article);
+}
+function mergeProduct(_rawSources, externalResults, productNode) {
+  const offers = firstRecord(productNode?.offers);
+  const aggregateRating = firstRecord(productNode?.aggregateRating);
+  const product = {
+    ...mergePartialObjects(externalResults.map((result) => result.product)),
+    name: firstDefined(firstResultValue(externalResults, (result) => result.product?.name), jsonString([productNode].filter(isJsonLdNode), "name")),
+    brand: firstDefined(firstResultValue(externalResults, (result) => result.product?.brand), entityFromJsonLd(productNode?.brand)),
+    sku: firstDefined(firstResultValue(externalResults, (result) => result.product?.sku), jsonString([productNode].filter(isJsonLdNode), "sku")),
+    price: firstDefined(firstResultValue(externalResults, (result) => result.product?.price), jsonString([offers].filter(isJsonLdNode), "price")),
+    currency: firstDefined(
+      firstResultValue(externalResults, (result) => result.product?.currency),
+      jsonString([offers].filter(isJsonLdNode), "priceCurrency")
+    ),
+    availability: firstDefined(
+      firstResultValue(externalResults, (result) => result.product?.availability),
+      shortSchemaValue(jsonString([offers].filter(isJsonLdNode), "availability"))
+    ),
+    condition: firstDefined(
+      firstResultValue(externalResults, (result) => result.product?.condition),
+      shortSchemaValue(jsonString([offers].filter(isJsonLdNode), "itemCondition"))
+    ),
+    ratingValue: firstDefined(
+      firstResultValue(externalResults, (result) => result.product?.ratingValue),
+      parseNumber(jsonString([aggregateRating].filter(isJsonLdNode), "ratingValue"))
+    ),
+    reviewCount: firstDefined(
+      firstResultValue(externalResults, (result) => result.product?.reviewCount),
+      parseNumber(jsonString([aggregateRating].filter(isJsonLdNode), "reviewCount"))
+    )
+  };
+  return emptyToUndefined(product);
+}
+function mergeApp(rawSources, externalResults, appNode) {
+  const offers = firstRecord(appNode?.offers);
+  const app = {
+    ...mergePartialObjects(externalResults.map((result) => result.app)),
+    name: firstDefined(
+      firstResultValue(externalResults, (result) => result.app?.name),
+      rawSources.html.applicationName,
+      jsonString([appNode].filter(isJsonLdNode), "name")
+    ),
+    category: firstDefined(firstResultValue(externalResults, (result) => result.app?.category), jsonString([appNode].filter(isJsonLdNode), "applicationCategory")),
+    operatingSystem: firstDefined(
+      firstResultValue(externalResults, (result) => result.app?.operatingSystem),
+      jsonString([appNode].filter(isJsonLdNode), "operatingSystem")
+    ),
+    price: firstDefined(firstResultValue(externalResults, (result) => result.app?.price), jsonString([offers].filter(isJsonLdNode), "price")),
+    currency: firstDefined(firstResultValue(externalResults, (result) => result.app?.currency), jsonString([offers].filter(isJsonLdNode), "priceCurrency"))
+  };
+  return emptyToUndefined(app);
+}
+function mergeVideo(rawSources, externalResults, jsonLdNodes, embeddedNodes, videos) {
+  const externalVideo = mergePartialObjects(externalResults.map((result) => result.video));
+  const hasExternalVideo = Object.keys(externalVideo).length > 0;
+  const explicitExternalType = firstResultValue(externalResults, (result) => result.type);
+  const videoNode = findJsonLdNode(jsonLdNodes, ["VideoObject"]);
+  const openGraphType = rawSources.openGraph.type?.toLowerCase() ?? "";
+  const canTrustEmbeddedVideo = !explicitExternalType || explicitExternalType === "video" || explicitExternalType === "playlist" || openGraphType.includes("video") || Boolean(videoNode);
+  if (!hasExternalVideo && !canTrustEmbeddedVideo) {
+    return void 0;
+  }
+  const canUseEmbeddedFallbacks = hasExternalVideo || canTrustEmbeddedVideo;
+  const video = {
+    ...externalVideo,
+    id: firstDefined(
+      firstResultValue(externalResults, (result) => result.video?.id),
+      canUseEmbeddedFallbacks ? findStringByKeys([videoNode, ...embeddedNodes].filter(isJsonLdNode), ["videoId", "video_id"]) : void 0
+    ),
+    title: firstDefined(
+      firstResultValue(externalResults, (result) => result.video?.title),
+      jsonString([videoNode].filter(isJsonLdNode), "name"),
+      canUseEmbeddedFallbacks ? rawSources.openGraph.title : void 0,
+      canUseEmbeddedFallbacks ? findStringByKeys(embeddedNodes, ["videoTitle", "title"]) : void 0
+    ),
+    channel: firstDefined(firstResultValue(externalResults, (result) => result.video?.channel), entityFromEmbedded(embeddedNodes, ["channel", "ownerChannelName", "author"])),
+    publishedTime: firstDefined(
+      firstResultValue(externalResults, (result) => result.video?.publishedTime),
+      jsonString([videoNode].filter(isJsonLdNode), "uploadDate"),
+      canUseEmbeddedFallbacks ? findStringByKeys(embeddedNodes, ["publishDate", "publishedTime", "uploadDate", "datePublished"]) : void 0
+    ),
+    duration: firstDefined(
+      firstResultValue(externalResults, (result) => result.video?.duration),
+      jsonString([videoNode].filter(isJsonLdNode), "duration"),
+      canUseEmbeddedFallbacks ? findStringByKeys(embeddedNodes, ["duration", "lengthSeconds"]) : void 0
+    ),
+    category: firstDefined(firstResultValue(externalResults, (result) => result.video?.category), canUseEmbeddedFallbacks ? findStringByKeys(embeddedNodes, ["category"]) : void 0),
+    viewCount: firstDefined(
+      firstResultValue(externalResults, (result) => result.video?.viewCount),
+      canUseEmbeddedFallbacks ? parseNumber(findStringByKeys(embeddedNodes, ["viewCount", "views"])) : void 0
+    ),
+    tags: firstDefined(firstResultValue(externalResults, (result) => result.video?.tags), canUseEmbeddedFallbacks ? arrayOfStrings(findValueByKeys(embeddedNodes, ["tags", "keywords"])) : void 0)
+  };
+  const cleaned = emptyToUndefined(video);
+  const hasUsefulVideoIdentity = Boolean(cleaned?.id) || Boolean(cleaned?.duration) || Boolean(cleaned?.channel) || Boolean(cleaned?.publishedTime) || videos.length > 0 || rawSources.openGraph.videos.length > 0 || rawSources.twitter.videos.length > 0 || Boolean(videoNode);
+  if (!cleaned || !hasExternalVideo && !hasUsefulVideoIdentity) {
+    return void 0;
+  }
+  return cleaned;
+}
+function mergePlaylist(externalResults) {
+  const playlist = firstResultValue(externalResults, (result) => result.playlist);
+  if (!playlist) {
+    return void 0;
+  }
+  return {
+    videos: [],
+    ...playlist
+  };
+}
+function inferType(rawSources, externalResults, jsonLdNodes, article, product, app, playlist, videos, audio) {
+  const explicit = firstResultValue(externalResults, (result) => result.type);
+  if (explicit) {
+    return explicit;
+  }
+  if (playlist) {
+    return "playlist";
+  }
+  const ogType = rawSources.openGraph.type?.toLowerCase();
+  if (ogType?.includes("article") || article) {
+    return "article";
+  }
+  if (ogType?.includes("product") || product || hasJsonLdType(jsonLdNodes, ["Product"])) {
+    return "product";
+  }
+  if (ogType?.includes("image") || hasJsonLdType(jsonLdNodes, ["ImageObject"])) {
+    return "image";
+  }
+  if (ogType?.includes("video") || videos.length > 0 || hasJsonLdType(jsonLdNodes, ["VideoObject"])) {
+    return "video";
+  }
+  if (ogType?.includes("audio") || audio.length > 0 || hasJsonLdType(jsonLdNodes, ["AudioObject", "MusicRecording", "PodcastEpisode"])) {
+    return "audio";
+  }
+  if (app || hasJsonLdType(jsonLdNodes, ["SoftwareApplication", "MobileApplication", "WebApplication"])) {
+    return "app";
+  }
+  if (ogType?.includes("profile") || hasJsonLdType(jsonLdNodes, ["Person"])) {
+    return "profile";
+  }
+  return rawSources.openGraph.raw["og:type"] || rawSources.html.title ? "website" : "unknown";
+}
+function detectSourcesUsed(rawSources) {
+  const sources = [];
+  if (Object.keys(rawSources.openGraph.raw).length > 0) {
+    sources.push("openGraph");
+  }
+  if (Object.keys(rawSources.twitter.raw).length > 0) {
+    sources.push("twitter");
+  }
+  if (rawSources.jsonLd.nodes.length > 0) {
+    sources.push("jsonLd");
+  }
+  if (rawSources.embeddedData.items.length > 0) {
+    sources.push("embeddedData", ...rawSources.embeddedData.items.map((item) => item.source));
+  }
+  if (rawSources.oEmbed.links.length > 0 || rawSources.oEmbed.data.length > 0) {
+    sources.push("oEmbed");
+  }
+  if (rawSources.html.title || rawSources.html.description || rawSources.html.canonicalUrl) {
+    sources.push("html");
+  }
+  if (rawSources.images.length > 0 || rawSources.videos.length > 0 || rawSources.audio.length > 0) {
+    sources.push("media");
+  }
+  sources.push(...rawSources.adapters.map((result) => result.source), ...rawSources.plugins.map((result) => result.source));
+  return sources;
+}
+function diagnosticsWarnings(rawSources, externalResults, diagnostics) {
+  return uniqueStrings2([
+    ...diagnostics?.warnings ?? [],
+    ...rawSources.jsonLd.warnings,
+    ...externalResults.flatMap((result) => result.warnings ?? [])
+  ]);
+}
+function adapterDiagnostics(adapters) {
+  const adapter = adapters[0];
+  if (!adapter) {
+    return { matched: false };
+  }
+  let confidence = 55;
+  if (adapter.title) {
+    confidence += 15;
+  }
+  if (adapter.description) {
+    confidence += 10;
+  }
+  if ((adapter.images?.length ?? 0) > 0 || (adapter.videos?.length ?? 0) > 0) {
+    confidence += 15;
+  }
+  if (adapter.author) {
+    confidence += 5;
+  }
+  return {
+    matched: true,
+    name: adapter.source,
+    confidence: Math.min(confidence, 100)
+  };
+}
+function fieldSource(rawSources, externalResults, embeddedNodes, field, bestImage) {
+  if (field === "image") {
+    return bestImage ? sourceLabel2(bestImage) : void 0;
+  }
+  for (const result of externalResults) {
+    if (field === "title" && result.title) {
+      return result.source;
+    }
+    if (field === "description" && result.description) {
+      return result.source;
+    }
+    if (field === "author" && result.author) {
+      return result.source;
+    }
+  }
+  if (field === "title") {
+    if (rawSources.openGraph.title) return "openGraph";
+    if (rawSources.twitter.title) return "twitter";
+    if (findStringByKeys(embeddedNodes, ["title", "headline", "name"])) return "embeddedData";
+    if (rawSources.html.title) return "html";
+  }
+  if (field === "description") {
+    if (rawSources.openGraph.description) return "openGraph";
+    if (rawSources.twitter.description) return "twitter";
+    if (findStringByKeys(embeddedNodes, ["description", "summary", "excerpt"])) return "embeddedData";
+    if (rawSources.html.description) return "html";
+  }
+  if (field === "author") {
+    if (entityFromEmbedded(embeddedNodes, ["author", "creator", "owner", "user"])) return "embeddedData";
+    if (rawSources.openGraph.article?.authors?.length) return "openGraph";
+  }
+  return void 0;
+}
+function findJsonLdNode(nodes, types) {
+  return nodes.find((node) => hasJsonLdType([node], types));
+}
+function hasJsonLdType(nodes, types) {
+  return nodes.some((node) => {
+    const nodeTypes = Array.isArray(node["@type"]) ? node["@type"] : [node["@type"]];
+    return nodeTypes.some((type) => typeof type === "string" && types.some((candidate) => type.toLowerCase().endsWith(candidate.toLowerCase())));
+  });
+}
+function jsonString(nodes, key) {
+  for (const node of nodes) {
+    const value = stringFromUnknown2(node[key]);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function findStringByKeys(nodes, keys) {
+  const normalizedKeys = keys.map((key) => key.toLowerCase());
+  const candidates = [];
+  for (const node of nodes) {
+    walkJson(node, (value, key) => {
+      if (!key || !normalizedKeys.includes(key.toLowerCase())) {
+        return;
+      }
+      const text = stringFromUnknown2(value);
+      if (text) {
+        candidates.push(text);
+      }
+    });
+  }
+  return candidates.filter((candidate) => candidate.length >= 2 && !/^\d+$/.test(candidate)).sort((left, right) => scoreTextCandidate(right) - scoreTextCandidate(left))[0];
+}
+function findValueByKeys(nodes, keys) {
+  const normalizedKeys = keys.map((key) => key.toLowerCase());
+  let found;
+  for (const node of nodes) {
+    walkJson(node, (value, key) => {
+      if (found !== void 0 || !key || !normalizedKeys.includes(key.toLowerCase())) {
+        return;
+      }
+      found = value;
+    });
+    if (found !== void 0) {
+      return found;
+    }
+  }
+  return void 0;
+}
+function entityFromEmbedded(nodes, keys) {
+  const normalizedKeys = keys.map((key) => key.toLowerCase());
+  const candidates = [];
+  for (const node of nodes) {
+    walkJson(node, (value, key) => {
+      if (!key || !normalizedKeys.some((candidate) => key.toLowerCase().includes(candidate))) {
+        return;
+      }
+      const entity = entityFromJsonLd(value);
+      if (entity?.name) {
+        candidates.push(entity);
+      }
+    });
+  }
+  return candidates[0];
+}
+function walkJson(value, visit, key, depth = 0) {
+  if (depth > 8) {
+    return;
+  }
+  visit(value, key);
+  if (Array.isArray(value)) {
+    for (const item of value.slice(0, 250)) {
+      walkJson(item, visit, void 0, depth + 1);
+    }
+    return;
+  }
+  if (isJsonLdNode(value)) {
+    for (const [childKey, childValue] of Object.entries(value).slice(0, 500)) {
+      walkJson(childValue, visit, childKey, depth + 1);
+    }
+  }
+}
+function scoreTextCandidate(value) {
+  let score = Math.min(value.length, 160);
+  if (value.length >= 12 && value.length <= 120) {
+    score += 50;
+  }
+  if (/^(home|login|index|untitled)$/i.test(value)) {
+    score -= 80;
+  }
+  return score;
+}
+function jsonKeywords(node) {
+  const value = node?.keywords;
+  if (!value) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.map(stringFromUnknown2).filter((item) => Boolean(item));
+  }
+  const text = stringFromUnknown2(value);
+  return text ? text.split(",").map((item) => item.trim()).filter(Boolean) : [];
+}
+function entityFromJsonLd(value) {
+  const entity = firstRecord(value);
+  if (!entity) {
+    const name = stringFromUnknown2(value);
+    return name ? { name } : void 0;
+  }
+  return emptyToUndefined({
+    name: stringFromUnknown2(entity.name),
+    url: stringFromUnknown2(entity.url),
+    logo: stringFromUnknown2(entity.logo),
+    sameAs: arrayOfStrings(entity.sameAs)
+  });
+}
+function entitiesFromJsonLd(value) {
+  if (Array.isArray(value)) {
+    const entities = value.map(entityFromJsonLd).filter((entity2) => Boolean(entity2));
+    return entities.length > 0 ? entities : void 0;
+  }
+  const entity = entityFromJsonLd(value);
+  return entity ? [entity] : void 0;
+}
+function firstRecord(value) {
+  if (Array.isArray(value)) {
+    return value.find(isJsonLdNode);
+  }
+  return isJsonLdNode(value) ? value : void 0;
+}
+function firstResultValue(results, select) {
+  for (const result of results) {
+    const value = select(result);
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function firstEntity(entities) {
+  return entities?.[0];
+}
+function mergePartialObjects(objects) {
+  return Object.assign({}, ...objects.filter(Boolean));
+}
+function stringFromUnknown2(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(stringFromUnknown2).find(Boolean);
+  }
+  if (isJsonLdNode(value)) {
+    return stringFromUnknown2(value.name) ?? stringFromUnknown2(value.url) ?? stringFromUnknown2(value["@id"]);
+  }
+  return void 0;
+}
+function arrayOfStrings(value) {
+  if (!Array.isArray(value)) {
+    const single = stringFromUnknown2(value);
+    return single ? [single] : void 0;
+  }
+  const values = value.map(stringFromUnknown2).filter((item) => Boolean(item));
+  return values.length > 0 ? values : void 0;
+}
+function shortSchemaValue(value) {
+  return value?.split("/").filter(Boolean).at(-1);
+}
+function domainName(url) {
+  try {
+    return new URL(url).hostname.replace(/^www\./, "");
+  } catch {
+    return void 0;
+  }
+}
+function uniqueStrings2(values) {
+  return [...new Set(values.filter((value) => Boolean(value)))];
+}
+function emptyToUndefined(value) {
+  const cleaned = stripUndefined2(value);
+  return Object.keys(cleaned).length > 0 ? cleaned : void 0;
+}
+function stripUndefined2(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0 && item !== null && (!Array.isArray(item) || item.length > 0)));
+}
+function isJsonLdNode(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sourceLabel2(image) {
+  if (image.source === "adapter") {
+    const adapter = typeof image.metadata?.adapter === "string" ? image.metadata.adapter : "adapter";
+    const originalSource = typeof image.metadata?.originalSource === "string" ? image.metadata.originalSource : void 0;
+    return originalSource ? `${adapter} (${originalSource})` : adapter;
+  }
+  return image.source;
+}
+
+// src/adapters/siteAdapters.ts
+var youtubeAdapter = {
+  name: "youtubeAdapter",
+  detect(url) {
+    return hostMatches(url, ["youtube.com", "youtu.be", "youtube-nocookie.com"]);
+  },
+  canHandle(url) {
+    return this.detect?.(url) ?? false;
+  },
+  extract(context) {
+    const url = new URL(context.finalUrl);
+    const videoId = getYouTubeVideoId(url);
+    const playlistId = getYouTubePlaylistId(url);
+    const communityPostId = getYouTubeCommunityPostId(url);
+    const channel = entityFromContext(context, ["author", "ownerChannelName", "channel", "owner"]);
+    const playlistVideos = playlistId ? extractPlaylistVideos(context) : [];
+    return compactAdapterResult({
+      source: "youtubeAdapter",
+      platform: "YouTube",
+      type: playlistId ? "playlist" : communityPostId ? "social_post" : "video",
+      siteName: "YouTube",
+      canonicalUrl: videoId ? `https://www.youtube.com/watch?v=${videoId}` : context.raw.openGraph.url,
+      title: titleFromContext(context, ["videoDetails", "title", "headline", "name", "contentText"]),
+      description: descriptionFromContext(context),
+      videos: markAdapterMedia(mediaFromContext(context).videos, "youtubeAdapter"),
+      images: markAdapterMedia(mediaFromContext(context).images, "youtubeAdapter"),
+      author: channel,
+      article: { publishedTime: publishedTimeFromContext(context) },
+      video: videoId ? {
+        id: videoId,
+        title: titleFromContext(context, ["videoDetails", "title"]),
+        channel,
+        publishedTime: publishedTimeFromContext(context),
+        duration: findEmbeddedString(context, ["duration", "lengthSeconds", "approxDurationMs"]),
+        tags: arrayFromContext(context, ["tags", "keywords"]),
+        category: findEmbeddedString(context, ["category"]),
+        viewCount: numberFromContext(context, ["viewCount", "views"])
+      } : void 0,
+      playlist: playlistId ? {
+        id: playlistId,
+        title: findEmbeddedString(context, ["playlistTitle", "playlistName", "title"]) ?? context.raw.openGraph.title,
+        channel,
+        videos: playlistVideos
+      } : void 0,
+      identifiers: { videoId, playlistId, communityPostId }
+    });
+  },
+  normalize(rawData) {
+    return normalizePlatformResult(rawData);
+  }
+};
+var redditAdapter = {
+  name: "redditAdapter",
+  detect(url) {
+    return hostMatches(url, ["reddit.com", "redd.it"]);
+  },
+  canHandle(url) {
+    return this.detect?.(url) ?? false;
+  },
+  extract(context) {
+    const url = new URL(context.finalUrl);
+    const reddit = parseRedditUrl(url);
+    const username = typeof reddit.username === "string" ? reddit.username : void 0;
+    return compactAdapterResult({
+      source: "redditAdapter",
+      platform: "Reddit",
+      type: reddit.isPost ? "social_post" : "website",
+      siteName: "Reddit",
+      canonicalUrl: context.raw.openGraph.url,
+      title: cleanSocialTitle(titleFromContext(context, ["title", "postTitle", "headline"])),
+      description: descriptionFromContext(context),
+      images: markAdapterMedia(mediaFromContext(context).images, "redditAdapter"),
+      videos: markAdapterMedia(mediaFromContext(context).videos, "redditAdapter"),
+      author: username ? { name: username } : entityFromContext(context, ["author", "submitter", "user"]),
+      article: { publishedTime: publishedTimeFromContext(context) },
+      identifiers: { subreddit: reddit.subreddit, postId: reddit.postId, username: reddit.username },
+      raw: { ...reddit }
+    });
+  },
+  normalize(rawData) {
+    return normalizePlatformResult(rawData);
+  }
+};
+var pinterestAdapter = {
+  name: "pinterestAdapter",
+  detect(url) {
+    return hostMatches(url, ["pinterest.com", "pin.it"]);
+  },
+  canHandle(url) {
+    return this.detect?.(url) ?? false;
+  },
+  extract(context) {
+    const url = new URL(context.finalUrl);
+    const pinId = url.pathname.match(/\/pin\/([^/]+)/)?.[1];
+    return compactAdapterResult({
+      source: "pinterestAdapter",
+      platform: "Pinterest",
+      type: pinId || hostMatches(url, ["pin.it"]) ? "social_post" : "image",
+      siteName: "Pinterest",
+      canonicalUrl: context.raw.openGraph.url,
+      title: titleFromContext(context, ["title", "pinTitle", "gridTitle", "headline", "name"]),
+      description: descriptionFromContext(context),
+      images: markAdapterMedia(mediaFromContext(context).images, "pinterestAdapter"),
+      videos: markAdapterMedia(mediaFromContext(context).videos, "pinterestAdapter"),
+      author: entityFromContext(context, ["pinner", "author", "creator", "owner", "user"]),
+      article: { publishedTime: publishedTimeFromContext(context) },
+      identifiers: { pinId }
+    });
+  },
+  normalize(rawData) {
+    return normalizePlatformResult(rawData);
+  }
+};
+var behanceAdapter = {
+  name: "behanceAdapter",
+  detect(url) {
+    return hostMatches(url, ["behance.net"]);
+  },
+  canHandle(url) {
+    return this.detect?.(url) ?? false;
+  },
+  extract(context) {
+    const url = new URL(context.finalUrl);
+    const projectId = url.pathname.match(/\/gallery\/(\d+)/)?.[1];
+    return compactAdapterResult({
+      source: "behanceAdapter",
+      platform: "Behance",
+      type: projectId ? "image" : "website",
+      siteName: "Behance",
+      canonicalUrl: context.raw.openGraph.url,
+      title: titleFromContext(context, ["title", "projectTitle", "name", "headline"]),
+      description: descriptionFromContext(context),
+      images: markAdapterMedia(mediaFromContext(context).images, "behanceAdapter"),
+      videos: markAdapterMedia(mediaFromContext(context).videos, "behanceAdapter"),
+      author: entityFromContext(context, ["owners", "author", "creator", "user"]),
+      article: { publishedTime: publishedTimeFromContext(context) },
+      raw: { projectId }
+    });
+  },
+  normalize(rawData) {
+    return normalizePlatformResult(rawData);
+  }
+};
+var tiktokAdapter = {
+  name: "tiktokAdapter",
+  detect(url) {
+    return hostMatches(url, ["tiktok.com"]);
+  },
+  canHandle(url) {
+    return this.detect?.(url) ?? false;
+  },
+  extract(context) {
+    return socialVideoResult("tiktokAdapter", "TikTok", context);
+  },
+  normalize(rawData) {
+    return normalizePlatformResult(rawData);
+  }
+};
+var facebookAdapter = {
+  name: "facebookAdapter",
+  detect(url) {
+    return hostMatches(url, ["facebook.com", "fb.watch"]);
+  },
+  canHandle(url) {
+    return this.detect?.(url) ?? false;
+  },
+  extract(context) {
+    const url = new URL(context.finalUrl);
+    const isPost = /\/(?:posts|photo|videos|watch|reel|share)\//i.test(url.pathname) || url.searchParams.has("story_fbid");
+    const isPhoto = url.pathname.includes("photo.php") || url.searchParams.has("fbid");
+    const postId = url.searchParams.get("story_fbid") ?? url.pathname.match(/\/(?:posts|videos|reel)\/([^/]+)/)?.[1];
+    const media = mediaFromContext(context);
+    return compactAdapterResult({
+      source: "facebookAdapter",
+      platform: "Facebook",
+      type: isPhoto ? "image" : isPost || media.images.length > 0 || media.videos.length > 0 ? "social_post" : "website",
+      siteName: "Facebook",
+      title: titleFromContext(context, ["title", "headline", "name"]),
+      description: descriptionFromContext(context),
+      images: markAdapterMedia(media.images, "facebookAdapter"),
+      videos: markAdapterMedia(media.videos, "facebookAdapter"),
+      author: entityFromContext(context, ["author", "owner", "profile", "user"]),
+      article: { publishedTime: publishedTimeFromContext(context) },
+      identifiers: { postId }
+    });
+  },
+  normalize(rawData) {
+    return normalizePlatformResult(rawData);
+  }
+};
+var twitterAdapter = {
+  name: "twitterAdapter",
+  detect(url) {
+    return hostMatches(url, ["twitter.com", "x.com", "t.co"]);
+  },
+  canHandle(url) {
+    return this.detect?.(url) ?? false;
+  },
+  extract(context) {
+    const url = new URL(context.finalUrl);
+    const statusId = url.pathname.match(/\/status(?:es)?\/(\d+)/)?.[1];
+    return compactAdapterResult({
+      source: "twitterAdapter",
+      platform: "X",
+      type: statusId || hostMatches(url, ["t.co"]) ? "social_post" : "profile",
+      siteName: "X",
+      canonicalUrl: context.raw.openGraph.url,
+      title: titleFromContext(context, ["title", "full_text", "text", "headline"]),
+      description: descriptionFromContext(context),
+      images: markAdapterMedia(mediaFromContext(context).images, "twitterAdapter"),
+      videos: markAdapterMedia(mediaFromContext(context).videos, "twitterAdapter"),
+      author: entityFromContext(context, ["author", "user", "screen_name", "creator"]),
+      article: { publishedTime: publishedTimeFromContext(context) },
+      identifiers: { statusId }
+    });
+  },
+  normalize(rawData) {
+    return normalizePlatformResult(rawData);
+  }
+};
+var instagramAdapter = {
+  name: "instagramAdapter",
+  detect(url) {
+    return hostMatches(url, ["instagram.com"]);
+  },
+  canHandle(url) {
+    return this.detect?.(url) ?? false;
+  },
+  extract(context) {
+    const url = new URL(context.finalUrl);
+    const shortcode = url.pathname.match(/\/(?:p|reel|tv)\/([^/]+)/)?.[1];
+    return compactAdapterResult({
+      source: "instagramAdapter",
+      platform: "Instagram",
+      type: shortcode ? "social_post" : "profile",
+      siteName: "Instagram",
+      canonicalUrl: context.raw.openGraph.url,
+      title: titleFromContext(context, ["title", "caption", "edge_media_to_caption", "headline"]),
+      description: descriptionFromContext(context),
+      images: markAdapterMedia(mediaFromContext(context).images, "instagramAdapter"),
+      videos: markAdapterMedia(mediaFromContext(context).videos, "instagramAdapter"),
+      author: entityFromContext(context, ["owner", "author", "user", "username"]),
+      article: { publishedTime: publishedTimeFromContext(context) },
+      identifiers: { shortcode }
+    });
+  },
+  normalize(rawData) {
+    return normalizePlatformResult(rawData);
+  }
+};
+var defaultAdapters = [
+  youtubeAdapter,
+  redditAdapter,
+  pinterestAdapter,
+  behanceAdapter,
+  tiktokAdapter,
+  facebookAdapter,
+  twitterAdapter,
+  instagramAdapter
+];
+function socialVideoResult(source, platform, context) {
+  const url = new URL(context.finalUrl);
+  const username = url.pathname.match(/@([^/]+)/)?.[1];
+  const postId = url.pathname.match(/\/(?:video|photo)\/([^/]+)/)?.[1] ?? url.pathname.split("/").filter(Boolean).at(-1);
+  return compactAdapterResult({
+    source,
+    platform,
+    type: "social_post",
+    siteName: platform,
+    canonicalUrl: context.raw.openGraph.url,
+    title: titleFromContext(context, ["title", "desc", "description", "caption"]),
+    description: descriptionFromContext(context),
+    images: markAdapterMedia(mediaFromContext(context).images, source),
+    videos: markAdapterMedia(mediaFromContext(context).videos, source),
+    author: username ? { name: username } : entityFromContext(context, ["author", "user", "creator", "owner"]),
+    article: { publishedTime: publishedTimeFromContext(context) },
+    identifiers: { username, postId }
+  });
+}
+function normalizePlatformResult(rawData) {
+  const type = rawData.type ?? inferAdapterType(rawData);
+  return compactAdapterResult({
+    ...rawData,
+    type,
+    raw: {
+      ...rawData.raw ?? {},
+      platform: rawData.platform,
+      identifiers: rawData.identifiers
+    }
+  });
+}
+function inferAdapterType(rawData) {
+  if ((rawData.videos?.length ?? 0) > 0) {
+    return "video";
+  }
+  if ((rawData.images?.length ?? 0) > 0) {
+    return "image";
+  }
+  return "website";
+}
+function markAdapterMedia(assets, adapterName) {
+  const seen = /* @__PURE__ */ new Set();
+  return assets.filter((asset) => {
+    if (seen.has(asset.url)) {
+      return false;
+    }
+    seen.add(asset.url);
+    return true;
+  }).map((asset) => ({
+    ...asset,
+    source: "adapter",
+    metadata: {
+      ...asset.metadata,
+      adapter: adapterName,
+      originalSource: asset.source
+    }
+  }));
+}
+function titleFromContext(context, embeddedKeys) {
+  return firstText(
+    context.raw.openGraph.title,
+    context.raw.twitter.title,
+    findEmbeddedString(context, embeddedKeys),
+    context.raw.html.title
+  );
+}
+function descriptionFromContext(context) {
+  return firstText(
+    context.raw.openGraph.description,
+    context.raw.twitter.description,
+    findEmbeddedString(context, ["description", "desc", "summary", "excerpt", "caption", "text"]),
+    context.raw.html.description
+  );
+}
+function publishedTimeFromContext(context) {
+  return firstText(
+    context.raw.openGraph.article?.publishedTime,
+    findJsonLdString(context.raw.jsonLd.nodes, ["datePublished", "uploadDate", "createdAt"]),
+    findEmbeddedString(context, ["datePublished", "publishedTime", "published_at", "createdAt", "created_at", "uploadDate", "timestamp"])
+  );
+}
+function mediaFromContext(context) {
+  const discovered = discoverMedia(context.raw, context.finalUrl);
+  return {
+    images: discovered.images,
+    videos: discovered.videos
+  };
+}
+function entityFromContext(context, keys) {
+  const jsonLdEntity = entityFromJsonValue(findJsonLdValue(context.raw.jsonLd.nodes, keys));
+  if (jsonLdEntity) {
+    return jsonLdEntity;
+  }
+  for (const item of context.raw.embeddedData.items) {
+    const entity = entityFromJsonValue(findValueByKeys2(item.data, keys));
+    if (entity) {
+      return entity;
+    }
+  }
+  return void 0;
+}
+function findEmbeddedString(context, keys) {
+  const candidates = [];
+  for (const item of context.raw.embeddedData.items) {
+    walkData(item.data, (value, key) => {
+      if (!key || !matchesKey(key, keys)) {
+        return;
+      }
+      const text = stringFromUnknown3(value);
+      if (text) {
+        candidates.push(text);
+      }
+    });
+  }
+  return bestTextCandidate(candidates);
+}
+function findJsonLdString(nodes, keys) {
+  const value = findJsonLdValue(nodes, keys);
+  return stringFromUnknown3(value);
+}
+function findJsonLdValue(nodes, keys) {
+  for (const node of nodes) {
+    const value = findValueByKeys2(node, keys);
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function findValueByKeys2(node, keys) {
+  let found;
+  walkData(node, (value, key) => {
+    if (found !== void 0 || !key || !matchesKey(key, keys)) {
+      return;
+    }
+    found = value;
+  });
+  return found;
+}
+function walkData(value, visit, key, depth = 0) {
+  if (depth > 8) {
+    return;
+  }
+  visit(value, key);
+  if (Array.isArray(value)) {
+    for (const item of value.slice(0, 250)) {
+      walkData(item, visit, void 0, depth + 1);
+    }
+    return;
+  }
+  if (isRecord4(value)) {
+    for (const [childKey, childValue] of Object.entries(value).slice(0, 500)) {
+      walkData(childValue, visit, childKey, depth + 1);
+    }
+  }
+}
+function entityFromJsonValue(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return { name: value };
+  }
+  if (Array.isArray(value)) {
+    return value.map(entityFromJsonValue).find(Boolean);
+  }
+  if (!isRecord4(value)) {
+    return void 0;
+  }
+  const name = stringFromUnknown3(value.name) ?? stringFromUnknown3(value.username) ?? stringFromUnknown3(value.screen_name) ?? stringFromUnknown3(value.ownerChannelName) ?? stringFromUnknown3(value.title);
+  if (!name) {
+    return void 0;
+  }
+  return {
+    name,
+    url: stringFromUnknown3(value.url) ?? stringFromUnknown3(value.canonicalUrl),
+    logo: stringFromUnknown3(value.logo) ?? stringFromUnknown3(value.avatar) ?? stringFromUnknown3(value.image)
+  };
+}
+function firstText(...values) {
+  return bestTextCandidate(values.filter((value) => Boolean(value)));
+}
+function bestTextCandidate(values) {
+  return values.map((value) => value.replace(/\s+/g, " ").trim()).filter((value) => value.length > 0).sort((left, right) => scoreText(right) - scoreText(left))[0];
+}
+function scoreText(value) {
+  let score = Math.min(value.length, 180);
+  if (value.length >= 10 && value.length <= 140) {
+    score += 60;
+  }
+  if (/^(home|login|index|untitled)$/i.test(value)) {
+    score -= 100;
+  }
+  return score;
+}
+function stringFromUnknown3(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const values = value.map(stringFromUnknown3).filter(Boolean);
+    return values.length > 0 ? values.join("") : void 0;
+  }
+  if (isRecord4(value)) {
+    return stringFromUnknown3(value.text) ?? stringFromUnknown3(value.simpleText) ?? stringFromUnknown3(value.runs) ?? stringFromUnknown3(value.title) ?? stringFromUnknown3(value.name) ?? stringFromUnknown3(value.value) ?? stringFromUnknown3(value.url);
+  }
+  return void 0;
+}
+function matchesKey(key, keys) {
+  const normalized = key.toLowerCase();
+  return keys.some((candidate) => normalized === candidate.toLowerCase() || normalized.endsWith(candidate.toLowerCase()));
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRedditUrl(url) {
+  const parts = url.pathname.split("/").filter(Boolean);
+  const commentsIndex = parts.indexOf("comments");
+  const shortPostId = hostMatches(url, ["redd.it"]) ? parts[0] : void 0;
+  return {
+    isPost: commentsIndex !== -1 || Boolean(shortPostId),
+    subreddit: parts[0] === "r" ? parts[1] : void 0,
+    postId: commentsIndex !== -1 ? parts[commentsIndex + 1] : shortPostId,
+    username: parts[0] === "user" ? parts[1] : void 0
+  };
+}
+function cleanSocialTitle(title) {
+  return title?.replace(/\s*:\s*r\/[A-Za-z0-9_]+$/i, "").trim();
+}
+function hostMatches(url, domains) {
+  const host = url.hostname.toLowerCase().replace(/^www\./, "");
+  return domains.some((domain) => host === domain || host.endsWith(`.${domain}`));
+}
+function getYouTubeVideoId(url) {
+  const host = url.hostname.toLowerCase().replace(/^www\./, "");
+  if (host === "youtu.be") {
+    return url.pathname.split("/").filter(Boolean)[0];
+  }
+  if (url.pathname === "/watch") {
+    return url.searchParams.get("v") ?? void 0;
+  }
+  const embedMatch = url.pathname.match(/\/(?:embed|shorts)\/([^/?]+)/);
+  return embedMatch?.[1];
+}
+function getYouTubePlaylistId(url) {
+  return url.searchParams.get("list") ?? void 0;
+}
+function getYouTubeCommunityPostId(url) {
+  return url.pathname.match(/\/post\/([^/?]+)/)?.[1];
+}
+function extractPlaylistVideos(context) {
+  const videos = /* @__PURE__ */ new Map();
+  for (const item of context.raw.embeddedData.items) {
+    walkData(item.data, (value) => {
+      if (!isRecord4(value)) {
+        return;
+      }
+      const videoId = stringFromUnknown3(value.videoId) ?? stringFromUnknown3(value.video_id) ?? (isRecord4(value.watchEndpoint) ? stringFromUnknown3(value.watchEndpoint.videoId) : void 0) ?? (isRecord4(value.navigationEndpoint) && isRecord4(value.navigationEndpoint.watchEndpoint) ? stringFromUnknown3(value.navigationEndpoint.watchEndpoint.videoId) : void 0);
+      if (!videoId || videos.has(videoId)) {
+        return;
+      }
+      videos.set(videoId, {
+        id: videoId,
+        title: stringFromUnknown3(value.title) ?? stringFromUnknown3(value.headline) ?? stringFromUnknown3(value.shortBylineText),
+        url: `https://www.youtube.com/watch?v=${videoId}`
+      });
+    });
+  }
+  return [...videos.values()].slice(0, 100);
+}
+function arrayFromContext(context, keys) {
+  const fromJsonLd = arrayOfStrings2(findJsonLdValue(context.raw.jsonLd.nodes, keys));
+  if (fromJsonLd) {
+    return fromJsonLd;
+  }
+  for (const item of context.raw.embeddedData.items) {
+    const embedded = arrayOfStrings2(findValueByKeys2(item.data, keys));
+    if (embedded) {
+      return embedded;
+    }
+  }
+  return void 0;
+}
+function numberFromContext(context, keys) {
+  const fromJsonLd = numberFromUnknown(findJsonLdValue(context.raw.jsonLd.nodes, keys));
+  if (fromJsonLd !== void 0) {
+    return fromJsonLd;
+  }
+  for (const item of context.raw.embeddedData.items) {
+    const embedded = numberFromUnknown(findValueByKeys2(item.data, keys));
+    if (embedded !== void 0) {
+      return embedded;
+    }
+  }
+  return void 0;
+}
+function arrayOfStrings2(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const values = value.map(stringFromUnknown3).filter((item) => Boolean(item));
+    return values.length > 0 ? values : void 0;
+  }
+  const text = stringFromUnknown3(value);
+  if (!text) {
+    return void 0;
+  }
+  return text.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function numberFromUnknown(value) {
+  const text = stringFromUnknown3(value);
+  if (!text) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(text.replace(/[^\d]/g, ""), 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function compactAdapterResult(result) {
+  return Object.fromEntries(
+    Object.entries(result).filter(([, value]) => value !== void 0 && (!Array.isArray(value) || value.length > 0))
+  );
+}
+
+// src/plugins/registry.ts
+var globalPlugins = [];
+function registerGlobalPlugin(plugin) {
+  if (!globalPlugins.some((registered) => registered.name === plugin.name)) {
+    globalPlugins.push(plugin);
+  }
+}
+function createRegistry(options = {}) {
+  const registry = {
+    adapters: [...defaultAdapters, ...options.adapters ?? []],
+    extractors: [],
+    imageScorers: [...options.imageScorers ?? []]
+  };
+  const api = {
+    addAdapter(adapter) {
+      registry.adapters.push(adapter);
+    },
+    addExtractor(name, extractor) {
+      registry.extractors.push({ name, extract: extractor });
+    },
+    addImageScorer(scorer) {
+      registry.imageScorers.push(scorer);
+    }
+  };
+  for (const plugin of [...globalPlugins, ...options.plugins ?? []]) {
+    plugin.setup(api);
+  }
+  return registry;
+}
+
+// src/parse.ts
+function parseMetadata(html, url, options = {}) {
+  const finalUrl = resolveUrl(url);
+  const registry = createRegistry(options);
+  const diagnostics = createEmptyDiagnostics();
+  diagnostics.originalUrl = url;
+  diagnostics.finalUrl = finalUrl;
+  diagnostics.trace.push("validated and normalized URL");
+  const rawSources = {
+    html: extractHtmlMetadata(html),
+    openGraph: extractOpenGraph(html),
+    twitter: extractTwitterCards(html),
+    jsonLd: extractJsonLd(html),
+    embeddedData: extractEmbeddedData(html),
+    oEmbed: extractOEmbed(html, finalUrl),
+    images: extractImages(html, finalUrl),
+    videos: extractVideos(html, finalUrl),
+    audio: extractAudio(html, finalUrl),
+    adapters: [],
+    plugins: []
+  };
+  appendExtractionTrace(rawSources, diagnostics.trace);
+  const $ = loadDocument(html);
+  const fetchOptions = options;
+  if (fetchOptions.fetchOEmbed && rawSources.oEmbed.links.length > 0) {
+    diagnostics.warnings.push("parseMetadata is synchronous; oEmbed endpoints are discovered but not fetched. Use fetchMetadata or parseMetadataAsync.");
+  }
+  for (const extractor of registry.extractors) {
+    try {
+      const result = extractor.extract({ html, url, finalUrl, $, raw: rawSources, options });
+      if (isPromise(result)) {
+        diagnostics.warnings.push(`Plugin extractor "${extractor.name}" returned a Promise during parseMetadata; use fetchMetadata or pre-resolve async work.`);
+        continue;
+      }
+      rawSources.plugins.push(withSource(result, extractor.name));
+      diagnostics.trace.push(`plugin extractor matched: ${extractor.name}`);
+    } catch (error) {
+      diagnostics.warnings.push(`Plugin extractor "${extractor.name}" failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const parsedUrl = new URL(finalUrl);
+  for (const adapter of registry.adapters) {
+    if (!adapterMatches(adapter, parsedUrl)) {
+      continue;
+    }
+    try {
+      const context = { html, url, finalUrl, $, raw: rawSources, options };
+      const result = adapter.extract(context);
+      if (isPromise(result)) {
+        diagnostics.warnings.push(`Adapter "${adapter.name}" returned a Promise during parseMetadata; use fetchMetadata or a synchronous adapter.`);
+        continue;
+      }
+      const normalized = adapter.normalize?.(result, context);
+      if (normalized && isPromise(normalized)) {
+        diagnostics.warnings.push(`Adapter "${adapter.name}" normalize returned a Promise during parseMetadata; use fetchMetadata or a synchronous adapter.`);
+        continue;
+      }
+      rawSources.adapters.push(withSource(normalized ?? result, adapter.name));
+      diagnostics.trace.push(`adapter matched: ${adapter.name}`);
+    } catch (error) {
+      diagnostics.warnings.push(`Adapter "${adapter.name}" failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return normalizeMetadata(rawSources, {
+    url,
+    finalUrl,
+    diagnostics,
+    imageScorers: registry.imageScorers,
+    includeRaw: options.includeRaw
+  });
+}
+async function parseMetadataAsync(html, url, options = {}) {
+  const finalUrl = resolveUrl(url);
+  const registry = createRegistry(options);
+  const diagnostics = createEmptyDiagnostics();
+  diagnostics.originalUrl = url;
+  diagnostics.finalUrl = finalUrl;
+  diagnostics.trace.push("validated and normalized URL");
+  const rawSources = {
+    html: extractHtmlMetadata(html),
+    openGraph: extractOpenGraph(html),
+    twitter: extractTwitterCards(html),
+    jsonLd: extractJsonLd(html),
+    embeddedData: extractEmbeddedData(html),
+    oEmbed: extractOEmbed(html, finalUrl),
+    images: extractImages(html, finalUrl),
+    videos: extractVideos(html, finalUrl),
+    audio: extractAudio(html, finalUrl),
+    adapters: [],
+    plugins: []
+  };
+  appendExtractionTrace(rawSources, diagnostics.trace);
+  const $ = loadDocument(html);
+  const fetchOptions = options;
+  if (fetchOptions.fetchOEmbed && rawSources.oEmbed.links.length > 0) {
+    const oEmbed = await fetchOEmbedData(rawSources.oEmbed.links, fetchOptions);
+    rawSources.oEmbed.data = oEmbed.data;
+    diagnostics.warnings.push(...oEmbed.warnings);
+    diagnostics.trace.push("fetched discovered oEmbed JSON endpoints");
+  }
+  for (const extractor of registry.extractors) {
+    try {
+      rawSources.plugins.push(withSource(await extractor.extract({ html, url, finalUrl, $, raw: rawSources, options }), extractor.name));
+      diagnostics.trace.push(`plugin extractor matched: ${extractor.name}`);
+    } catch (error) {
+      diagnostics.warnings.push(`Plugin extractor "${extractor.name}" failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const parsedUrl = new URL(finalUrl);
+  for (const adapter of registry.adapters) {
+    if (!adapterMatches(adapter, parsedUrl)) {
+      continue;
+    }
+    try {
+      const context = { html, url, finalUrl, $, raw: rawSources, options };
+      const result = await adapter.extract(context);
+      const normalized = adapter.normalize ? await adapter.normalize(result, context) : result;
+      rawSources.adapters.push(withSource(normalized, adapter.name));
+      diagnostics.trace.push(`adapter matched: ${adapter.name}`);
+    } catch (error) {
+      diagnostics.warnings.push(`Adapter "${adapter.name}" failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return normalizeMetadata(rawSources, {
+    url,
+    finalUrl,
+    diagnostics,
+    imageScorers: registry.imageScorers,
+    includeRaw: options.includeRaw
+  });
+}
+function withSource(result, source) {
+  return {
+    ...result,
+    source: result.source || source
+  };
+}
+function isPromise(value) {
+  return Boolean(value && typeof value.then === "function");
+}
+function adapterMatches(adapter, url) {
+  return adapter.detect?.(url) ?? adapter.canHandle?.(url) ?? false;
+}
+function appendExtractionTrace(rawSources, trace) {
+  if (Object.keys(rawSources.openGraph.raw).length > 0) {
+    trace.push("parsed Open Graph");
+  }
+  if (Object.keys(rawSources.twitter.raw).length > 0) {
+    trace.push("parsed Twitter Cards");
+  }
+  if (rawSources.jsonLd.nodes.length > 0) {
+    trace.push("parsed JSON-LD");
+  }
+  if (rawSources.embeddedData.items.length > 0) {
+    trace.push("parsed embedded application data");
+  }
+  if (rawSources.oEmbed.links.length > 0) {
+    trace.push("discovered oEmbed endpoints");
+  }
+  if (rawSources.images.length > 0 || rawSources.videos.length > 0 || rawSources.audio.length > 0) {
+    trace.push("discovered HTML media candidates");
+  }
+}
+
+// src/utils/imageDimensions.ts
+function detectImageDimensions(bytes, contentType) {
+  if (!bytes || bytes.length < 16) {
+    return {};
+  }
+  const type = contentType?.toLowerCase() ?? "";
+  if (type.includes("png") || isPng(bytes)) {
+    return readPngDimensions(bytes);
+  }
+  if (type.includes("jpeg") || type.includes("jpg") || isJpeg(bytes)) {
+    return readJpegDimensions(bytes);
+  }
+  if (type.includes("webp") || isWebp(bytes)) {
+    return readWebpDimensions(bytes);
+  }
+  return {};
+}
+function isPng(bytes) {
+  return bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
+}
+function isJpeg(bytes) {
+  return bytes[0] === 255 && bytes[1] === 216;
+}
+function isWebp(bytes) {
+  return ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WEBP";
+}
+function readPngDimensions(bytes) {
+  if (bytes.length < 24) {
+    return {};
+  }
+  return {
+    width: readUint32(bytes, 16),
+    height: readUint32(bytes, 20)
+  };
+}
+function readJpegDimensions(bytes) {
+  let offset = 2;
+  while (offset + 9 < bytes.length) {
+    if (bytes[offset] !== 255) {
+      offset += 1;
+      continue;
+    }
+    const marker = bytes[offset + 1];
+    const length = readUint16(bytes, offset + 2);
+    if (length < 2) {
+      return {};
+    }
+    if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker)) {
+      return {
+        height: readUint16(bytes, offset + 5),
+        width: readUint16(bytes, offset + 7)
+      };
+    }
+    offset += 2 + length;
+  }
+  return {};
+}
+function readWebpDimensions(bytes) {
+  const chunk = ascii(bytes, 12, 4);
+  if (chunk === "VP8X" && bytes.length >= 30) {
+    return {
+      width: 1 + readUint24Le(bytes, 24),
+      height: 1 + readUint24Le(bytes, 27)
+    };
+  }
+  if (chunk === "VP8 " && bytes.length >= 30) {
+    return {
+      width: readUint16Le(bytes, 26) & 16383,
+      height: readUint16Le(bytes, 28) & 16383
+    };
+  }
+  if (chunk === "VP8L" && bytes.length >= 25) {
+    const b0 = bytes[21];
+    const b1 = bytes[22];
+    const b2 = bytes[23];
+    const b3 = bytes[24];
+    return {
+      width: 1 + ((b1 & 63) << 8 | b0),
+      height: 1 + ((b3 & 15) << 10 | b2 << 2 | (b1 & 192) >> 6)
+    };
+  }
+  return {};
+}
+function readUint16(bytes, offset) {
+  return (bytes[offset] << 8) + bytes[offset + 1];
+}
+function readUint16Le(bytes, offset) {
+  return bytes[offset] + (bytes[offset + 1] << 8);
+}
+function readUint24Le(bytes, offset) {
+  return bytes[offset] + (bytes[offset + 1] << 8) + (bytes[offset + 2] << 16);
+}
+function readUint32(bytes, offset) {
+  return (bytes[offset] << 24 >>> 0) + (bytes[offset + 1] << 16) + (bytes[offset + 2] << 8) + bytes[offset + 3];
+}
+function ascii(bytes, offset, length) {
+  return String.fromCharCode(...bytes.slice(offset, offset + length));
+}
+
+// src/fetchMetadata.ts
+async function fetchMetadata(url, options = {}) {
+  const startedAt = Date.now();
+  try {
+    const requestedUrl = normalizeUrl(url);
+    const firstPage = await fetchPage(requestedUrl, options);
+    const fallback = await maybeFetchRedditFallback(firstPage, options);
+    const page = fallback.page;
+    const directMedia = createDirectMediaMetadata(page, requestedUrl, Date.now() - startedAt);
+    if (directMedia) {
+      return directMedia;
+    }
+    const metadata = await parseMetadataAsync(page.html, page.finalUrl, options);
+    metadata.url = requestedUrl;
+    metadata.finalUrl = page.finalUrl;
+    metadata.ok = page.statusCode >= 200 && page.statusCode < 300;
+    metadata.diagnostics.statusCode = page.statusCode;
+    metadata.diagnostics.contentType = page.contentType;
+    metadata.diagnostics.originalUrl = requestedUrl;
+    metadata.diagnostics.finalUrl = page.finalUrl;
+    metadata.diagnostics.canonicalUrl = metadata.canonicalUrl;
+    metadata.diagnostics.isShortUrl = page.isShortUrl;
+    metadata.diagnostics.shortUrlProvider = page.shortUrlProvider;
+    metadata.diagnostics.redirects = page.redirects;
+    metadata.diagnostics.fetchDurationMs = Date.now() - startedAt;
+    metadata.diagnostics.trace = [
+      ...page.isShortUrl ? [`detected short URL provider: ${page.shortUrlProvider ?? "unknown"}`] : [],
+      ...page.redirects.length > 0 ? [`resolved ${page.redirects.length} redirect${page.redirects.length === 1 ? "" : "s"}`] : [],
+      ...fallback.used ? ["retried Reddit page through old.reddit fallback"] : [],
+      "downloaded page",
+      ...metadata.diagnostics.trace,
+      ...metadata.canonicalUrl ? ["resolved canonical URL"] : []
+    ];
+    metadata.trace = metadata.diagnostics.trace;
+    if (!metadata.ok) {
+      metadata.diagnostics.warnings.push(`Fetch completed with non-success status code ${page.statusCode}.`);
+    }
+    if (page.contentType && !/html|xml|text/i.test(page.contentType)) {
+      metadata.diagnostics.warnings.push(`Response content type may not contain parseable metadata: ${page.contentType}.`);
+    }
+    return metadata;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const safeUrl = safeNormalize(url);
+    return {
+      ok: false,
+      url: safeUrl,
+      finalUrl: safeUrl,
+      type: "unknown",
+      confidence: 0,
+      completeness: 0,
+      reliability: 0,
+      images: [],
+      videos: [],
+      audio: [],
+      favicons: [],
+      trace: ["fetch failed"],
+      diagnostics: {
+        originalUrl: safeUrl,
+        finalUrl: safeUrl,
+        redirects: [],
+        sourcesUsed: [],
+        warnings: [],
+        trace: ["fetch failed"],
+        errors: [message],
+        fetchDurationMs: Date.now() - startedAt,
+        extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+}
+async function maybeFetchRedditFallback(page, options) {
+  let parsed;
+  try {
+    parsed = new URL(page.finalUrl);
+  } catch {
+    return { page, used: false };
+  }
+  const host = parsed.hostname.toLowerCase();
+  const isReddit = host === "www.reddit.com" || host === "reddit.com" || host.endsWith(".reddit.com");
+  const isOldReddit = host === "old.reddit.com";
+  const looksLikeVerification = /please wait for verification|blocked|whoa there, pardner/i.test(page.html);
+  const hasUsefulPreview = /og:(?:title|image|description)|twitter:(?:title|image|description)/i.test(page.html);
+  if (!isReddit || isOldReddit || hasUsefulPreview || !looksLikeVerification) {
+    return { page, used: false };
+  }
+  const fallbackUrl = new URL(page.finalUrl);
+  fallbackUrl.hostname = "old.reddit.com";
+  fallbackUrl.search = "";
+  try {
+    const fallbackPage = await fetchPage(fallbackUrl.toString(), options);
+    return { page: fallbackPage, used: true };
+  } catch {
+    return { page, used: false };
+  }
+}
+function createDirectMediaMetadata(page, requestedUrl, fetchDurationMs) {
+  const contentType = page.contentType?.toLowerCase() ?? "";
+  const kind = directMediaKind(contentType, page.finalUrl);
+  if (!kind) {
+    return void 0;
+  }
+  const dimensions = kind === "image" ? {
+    ...imageDimensionsFromUrl(page.finalUrl),
+    ...detectImageDimensions(page.bytes, page.contentType)
+  } : {};
+  const asset = {
+    url: page.finalUrl,
+    kind,
+    source: "direct",
+    type: page.contentType,
+    width: dimensions.width,
+    height: dimensions.height,
+    score: kind === "image" ? 90 : void 0,
+    confidence: kind === "image" ? 0.9 : void 0
+  };
+  const confidence = kind === "image" ? 82 : 70;
+  const completeness = kind === "image" ? dimensions.width && dimensions.height ? 60 : 45 : 35;
+  const trace = [
+    ...page.redirects.length > 0 ? [`resolved ${page.redirects.length} redirect${page.redirects.length === 1 ? "" : "s"}`] : [],
+    "downloaded direct media",
+    `detected direct ${kind}`
+  ];
+  return {
+    ok: page.statusCode >= 200 && page.statusCode < 300,
+    url: requestedUrl,
+    finalUrl: page.finalUrl,
+    type: kind === "image" ? "image" : kind,
+    confidence,
+    completeness,
+    reliability: Math.round((confidence + completeness) / 2),
+    bestImage: kind === "image" ? page.finalUrl : void 0,
+    images: kind === "image" ? [asset] : [],
+    videos: kind === "video" ? [asset] : [],
+    audio: kind === "audio" ? [asset] : [],
+    favicons: [],
+    trace,
+    sources: {
+      image: kind === "image" ? "direct" : void 0
+    },
+    diagnostics: {
+      originalUrl: requestedUrl,
+      finalUrl: page.finalUrl,
+      isShortUrl: page.isShortUrl,
+      shortUrlProvider: page.shortUrlProvider,
+      statusCode: page.statusCode,
+      contentType: page.contentType,
+      redirects: page.redirects,
+      sourcesUsed: ["direct"],
+      warnings: [],
+      trace,
+      selectedImageReason: kind === "image" ? "Selected direct image URL because the response content type is an image." : void 0,
+      fetchDurationMs,
+      extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function imageDimensionsFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const width = parseDimension(parsed.searchParams.get("width") ?? parsed.searchParams.get("w"));
+    const height = parseDimension(parsed.searchParams.get("height") ?? parsed.searchParams.get("h"));
+    if (width && height) {
+      return { width, height };
+    }
+    const crop = parsed.searchParams.get("crop");
+    const cropMatch = crop?.match(/(\d{2,5})\s*:\s*(\d{2,5})/);
+    if (cropMatch) {
+      return { width: Number(cropMatch[1]), height: Number(cropMatch[2]) };
+    }
+  } catch {
+    return {};
+  }
+  return {};
+}
+function parseDimension(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function directMediaKind(contentType, url) {
+  const normalizedUrl = url.toLowerCase();
+  if (contentType.startsWith("image/") || /\.(?:avif|webp|png|jpe?g|gif)(?:[?#].*)?$/i.test(normalizedUrl)) {
+    return "image";
+  }
+  if (contentType.startsWith("video/") || /\.(?:mp4|webm|m3u8|mov)(?:[?#].*)?$/i.test(normalizedUrl)) {
+    return "video";
+  }
+  if (contentType.startsWith("audio/") || /\.(?:mp3|m4a|wav|ogg|aac)(?:[?#].*)?$/i.test(normalizedUrl)) {
+    return "audio";
+  }
+  return void 0;
+}
+function safeNormalize(url) {
+  try {
+    return normalizeUrl(url);
+  } catch {
+    return url;
+  }
+}
+
+// src/preview.ts
+function createPreviewCard(metadata) {
+  return {
+    title: metadata.title,
+    description: metadata.description,
+    image: metadata.bestImage,
+    url: metadata.canonicalUrl ?? metadata.finalUrl,
+    siteName: metadata.siteName,
+    domain: domainFromUrl(metadata.canonicalUrl ?? metadata.finalUrl),
+    author: metadata.author?.name,
+    type: metadata.type,
+    confidence: metadata.confidence
+  };
+}
+function domainFromUrl(url) {
+  try {
+    return new URL(url).hostname.replace(/^www\./, "");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core.ts
+var MetaNova = {
+  use(plugin) {
+    registerGlobalPlugin(plugin);
+    return MetaNova;
+  },
+  fetchMetadata,
+  parseMetadata,
+  parseMetadataAsync,
+  createPreviewCard
+};
+
+// src/diagnostics/index.ts
+function createDiagnostics() {
+  return {
+    redirects: [],
+    sourcesUsed: [],
+    warnings: [],
+    trace: [],
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function addWarning(diagnostics, warning) {
+  diagnostics.warnings.push(warning);
+  return diagnostics;
+}
+
+// src/index.ts
+var index_default = MetaNova;
+export {
+  DEFAULT_ACCEPT,
+  DEFAULT_ACCEPT_ENCODING,
+  DEFAULT_ACCEPT_LANGUAGE,
+  DEFAULT_BROWSER_USER_AGENT,
+  MetaNova,
+  SecurityError,
+  addWarning,
+  assertSafeRequestUrl,
+  behanceAdapter,
+  calculateCompleteness,
+  calculateConfidence,
+  calculateReliability,
+  createDiagnostics,
+  createPreviewCard,
+  createRegistry,
+  index_default as default,
+  defaultAdapters,
+  detectShortUrl,
+  discoverMedia,
+  extractAudio,
+  extractEmbeddedData,
+  extractHtmlMetadata,
+  extractImages,
+  extractJsonLd,
+  extractOEmbed,
+  extractOpenGraph,
+  extractTwitterCards,
+  extractVideos,
+  facebookAdapter,
+  fetchMetadata,
+  fetchPage,
+  instagramAdapter,
+  normalizeMetadata,
+  normalizeUrl,
+  parseMetadata,
+  parseMetadataAsync,
+  pinterestAdapter,
+  redditAdapter,
+  registerGlobalPlugin,
+  resolveCanonicalUrl,
+  resolveRedirects,
+  resolveUrl,
+  scoreImages,
+  tiktokAdapter,
+  twitterAdapter,
+  validateUrl,
+  youtubeAdapter
+};
+//# sourceMappingURL=index.js.map