@postfetch/core 0.2.0

package/dist/index.js

@@ -0,0 +1,1089 @@
+// src/internal.ts
+class PostfetchError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "PostfetchError";
+  }
+}
+function createNet(baseFetch = globalThis.fetch) {
+  return async function net(url, init = {}, attempts = 3) {
+    let lastError;
+    for (let attempt = 1;attempt <= attempts; attempt += 1) {
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), 30000);
+      try {
+        const response = await baseFetch(url, { ...init, signal: controller.signal });
+        if (!retryable(response.status) || attempt === attempts) {
+          return response;
+        }
+        await sleep(retryDelay(response, attempt));
+      } catch (error) {
+        lastError = error;
+        if (attempt === attempts) {
+          break;
+        }
+        await sleep(500 * 2 ** (attempt - 1));
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error("request failed");
+  };
+}
+function object(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function string(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function number(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asUrl(value) {
+  try {
+    return new URL(value);
+  } catch {
+    throw new PostfetchError(400, "invalid url");
+  }
+}
+function filename(value) {
+  return value.replace(/[^A-Za-z0-9_.-]+/g, "_");
+}
+function retryable(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function retryDelay(response, attempt) {
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return seconds * 1000;
+    }
+    const time = Date.parse(retryAfter);
+    if (!Number.isNaN(time) && time > Date.now()) {
+      return time - Date.now();
+    }
+  }
+  return Math.min(500 * 2 ** (attempt - 1), 1e4);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/fingerprint.ts
+function pick(values) {
+  return values[Math.floor(Math.random() * values.length)];
+}
+var chromeVersions = ["128", "129", "130", "131", "132", "133"];
+var firefoxVersions = ["140", "143", "146", "148"];
+var desktopPlatforms = [
+  { chPlatform: "Windows", uaToken: "Windows NT 10.0; Win64; x64" },
+  { chPlatform: "macOS", uaToken: "Macintosh; Intel Mac OS X 10_15_7" },
+  { chPlatform: "Linux", uaToken: "X11; Linux x86_64" }
+];
+var acceptLanguages = ["en-US,en;q=0.9", "en-GB,en;q=0.9", "en;q=0.9", "en-US,en;q=0.8"];
+var instagramAppUserAgents = [
+  "Instagram 275.0.0.27.98 Android (33/13; 280dpi; 720x1423; Xiaomi; Redmi 7; onclite; qcom; en_US; 458229237)",
+  "Instagram 301.1.0.33.110 Android (34/14; 420dpi; 1080x2340; samsung; SM-G991B; o1s; exynos2100; en_US; 521879118)",
+  "Instagram 309.0.0.40.113 Android (33/13; 440dpi; 1080x2280; OnePlus; HD1913; OnePlus7TPro; qcom; en_US; 537291984)"
+];
+function browserFingerprint() {
+  const version = pick(chromeVersions);
+  const platform = pick(desktopPlatforms);
+  return {
+    acceptLanguage: pick(acceptLanguages),
+    secChUa: `"Chromium";v="${version}", "Google Chrome";v="${version}", "Not_A Brand";v="24"`,
+    secChUaPlatform: `"${platform.chPlatform}"`,
+    userAgent: `Mozilla/5.0 (${platform.uaToken}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${version}.0.0.0 Safari/537.36`
+  };
+}
+function navigationHeaders() {
+  const fingerprint = browserFingerprint();
+  return {
+    accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+    "accept-language": fingerprint.acceptLanguage,
+    "sec-ch-ua": fingerprint.secChUa,
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": fingerprint.secChUaPlatform,
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "none",
+    "sec-fetch-user": "?1",
+    "upgrade-insecure-requests": "1",
+    "user-agent": fingerprint.userAgent
+  };
+}
+function browserUserAgent() {
+  return browserFingerprint().userAgent;
+}
+function firefoxUserAgent() {
+  const platform = pick(desktopPlatforms);
+  const version = pick(firefoxVersions);
+  return `Mozilla/5.0 (${platform.uaToken}; rv:${version}.0) Gecko/20100101 Firefox/${version}.0`;
+}
+function instagramAppUserAgent() {
+  return pick(instagramAppUserAgents);
+}
+
+// src/facebook.ts
+async function resolveFacebook(input) {
+  const canonical = await canonicalUrl(input.net, input.url);
+  const id = facebookId(canonical) ?? facebookId(input.url) ?? "video";
+  const url = await embedVideo(input.net, canonical);
+  if (!url) {
+    throw new Error("Facebook video not found");
+  }
+  const item = {
+    filename: filename(`facebook_${id}.mp4`),
+    headers: { "user-agent": browserUserAgent() },
+    id,
+    kind: "video",
+    mime: "video/mp4",
+    platform: "facebook",
+    url
+  };
+  return { archiveFilename: filename(`facebook_${id}.zip`), id, items: [item], platform: "facebook" };
+}
+function navigationHeaders2() {
+  return {
+    "accept-language": "en-US,en;q=0.9",
+    "sec-fetch-mode": "navigate",
+    "user-agent": browserUserAgent()
+  };
+}
+async function canonicalUrl(net, input) {
+  const response = await net(input, { headers: navigationHeaders2() });
+  const resolved = asUrl(response.url);
+  return `${resolved.origin}${resolved.pathname}`;
+}
+async function embedVideo(net, canonical) {
+  const embed = `https://www.facebook.com/plugins/video.php?href=${encodeURIComponent(canonical)}`;
+  const response = await net(embed, { headers: navigationHeaders2() });
+  if (!response.ok) {
+    return null;
+  }
+  const html = await response.text();
+  return source(html, "hd_src") ?? source(html, "sd_src");
+}
+function source(html, key) {
+  const match = html.match(new RegExp(`"${key}":("(?:\\\\.|[^"\\\\])*")`));
+  if (!match) {
+    return null;
+  }
+  const decoded = JSON.parse(match[1]);
+  return typeof decoded === "string" && decoded.length > 0 ? decoded : null;
+}
+function facebookId(input) {
+  const url = asUrl(input);
+  const fromQuery = url.searchParams.get("v");
+  if (fromQuery && /^\d+$/.test(fromQuery)) {
+    return fromQuery;
+  }
+  const numeric = url.pathname.match(/\/(?:reel|videos?|watch)\/(\d+)/);
+  if (numeric) {
+    return numeric[1];
+  }
+  const token = url.pathname.match(/\/(?:share\/[a-z]\/|posts\/|videos\/)?([A-Za-z0-9]+)\/?$/);
+  return token ? token[1] : null;
+}
+
+// src/instagram.ts
+var appId = "936619743392459";
+function mobileHeaders() {
+  return {
+    "accept-language": "en-US",
+    "content-length": "0",
+    "user-agent": instagramAppUserAgent(),
+    "x-fb-client-ip": "True",
+    "x-fb-http-engine": "Liger",
+    "x-fb-server-cluster": "True",
+    "x-ig-app-locale": "en_US",
+    "x-ig-device-locale": "en_US",
+    "x-ig-mapped-locale": "en_US"
+  };
+}
+function embedHeaders() {
+  const fingerprint = browserFingerprint();
+  return {
+    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",
+    "Accept-Language": fingerprint.acceptLanguage,
+    "Cache-Control": "max-age=0",
+    Dnt: "1",
+    Priority: "u=0, i",
+    "Sec-Ch-Ua": fingerprint.secChUa,
+    "Sec-Ch-Ua-Mobile": "?0",
+    "Sec-Ch-Ua-Platform": fingerprint.secChUaPlatform,
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "none",
+    "Sec-Fetch-User": "?1",
+    "Upgrade-Insecure-Requests": "1",
+    "User-Agent": fingerprint.userAgent
+  };
+}
+async function resolveInstagram(input) {
+  const code = shortcode(input.url);
+  const media = await pageMedia(input.net, code, input.preferredWidth) ?? await mobileMedia(input.net, code, input.preferredWidth) ?? await embedMedia(input.net, code) ?? await graphqlMedia(input.net, code);
+  if (!media) {
+    throw new Error("Instagram media not found");
+  }
+  const items = mediaItems(media, code, input.preferredWidth);
+  if (items.length === 0) {
+    throw new Error("Instagram media url not found");
+  }
+  return { archiveFilename: filename(`instagram_${code}.zip`), id: code, items, platform: "instagram" };
+}
+function shortcode(input) {
+  const path = asUrl(input).pathname.split("/").filter(Boolean);
+  const index = path.findIndex((part) => part === "p" || part === "reel" || part === "reels" || part === "tv");
+  const code = index >= 0 ? path[index + 1] : path[path.length - 1];
+  if (!code) {
+    throw new Error("Instagram shortcode not found");
+  }
+  return code;
+}
+async function pageMedia(net, code, preferredWidth) {
+  const response = await net(`https://www.instagram.com/p/${code}/`, { headers: navigationHeaders() });
+  if (!response.ok) {
+    return null;
+  }
+  const html = await response.text();
+  const media = inlineMedia(html, code);
+  return media && mediaItems(media, code, preferredWidth).length > 0 ? media : null;
+}
+function inlineMedia(html, code) {
+  for (const match of html.matchAll(/<script type="application\/json"[^>]*>(.*?)<\/script>/gs)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(match[1]);
+    } catch {
+      continue;
+    }
+    const media = searchMedia(parsed, code);
+    if (media) {
+      return media;
+    }
+  }
+  return null;
+}
+function searchMedia(node, code) {
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      const media = searchMedia(child, code);
+      if (media) {
+        return media;
+      }
+    }
+    return null;
+  }
+  if (!object(node)) {
+    return null;
+  }
+  const hasMedia = Array.isArray(node.video_versions) || Array.isArray(node.carousel_media) || object(node.image_versions2) && Array.isArray(node.image_versions2.candidates);
+  if (hasMedia && node.code === code) {
+    return node;
+  }
+  for (const key in node) {
+    const media = searchMedia(node[key], code);
+    if (media) {
+      return media;
+    }
+  }
+  return null;
+}
+async function mobileMedia(net, code, preferredWidth) {
+  const id = await mediaId(net, code);
+  if (!id) {
+    return null;
+  }
+  const media = await mobileInfo(net, id);
+  return media && mediaItems(media, code, preferredWidth).length > 0 ? media : null;
+}
+async function mediaId(net, code) {
+  const url = new URL("https://i.instagram.com/api/v1/oembed/");
+  url.searchParams.set("url", `https://www.instagram.com/p/${code}/`);
+  const response = await net(url.href, { headers: mobileHeaders() }, 1);
+  if (!response.ok) {
+    return null;
+  }
+  const payload = await response.json().catch(() => null);
+  return object(payload) ? string(payload.media_id) : null;
+}
+async function mobileInfo(net, mediaId2) {
+  const response = await net(`https://i.instagram.com/api/v1/media/${mediaId2}/info/`, {
+    headers: mobileHeaders()
+  }, 1);
+  if (!response.ok) {
+    return null;
+  }
+  const payload = await response.json().catch(() => null);
+  const items = object(payload) && Array.isArray(payload.items) ? payload.items : [];
+  const first = items[0];
+  return object(first) ? first : null;
+}
+async function embedMedia(net, code) {
+  const response = await net(`https://www.instagram.com/p/${code}/embed/captioned/`, {
+    headers: embedHeaders()
+  });
+  if (!response.ok) {
+    return null;
+  }
+  const html = await response.text();
+  const init = html.match(/"init",\[\],\[(.*?)\]\],/s)?.[1];
+  if (!init) {
+    return null;
+  }
+  const parsed = JSON.parse(init);
+  const contextJson = object(parsed) ? string(parsed.contextJSON) : null;
+  if (!contextJson) {
+    return null;
+  }
+  const context = JSON.parse(contextJson);
+  if (!object(context)) {
+    return null;
+  }
+  const embedded = object(context.context) && object(context.context.media) ? context.context.media : null;
+  const gqlMedia = gqlShortcodeMedia(context);
+  return embedded ?? gqlMedia;
+}
+async function graphqlMedia(net, code) {
+  const params = await graphqlParams(net, code);
+  if (!params) {
+    return null;
+  }
+  const body = new URLSearchParams({
+    ...params.body,
+    doc_id: "8845758582119845",
+    fb_api_caller_class: "RelayModern",
+    fb_api_req_friendly_name: "PolarisPostActionLoadPostQueryQuery",
+    server_timestamps: "true",
+    variables: JSON.stringify({
+      fetch_tagged_user_count: null,
+      hoisted_comment_id: null,
+      hoisted_reply_id: null,
+      shortcode: code
+    })
+  });
+  const response = await net("https://www.instagram.com/graphql/query", {
+    body,
+    headers: {
+      ...embedHeaders(),
+      ...params.headers,
+      "X-FB-Friendly-Name": "PolarisPostActionLoadPostQueryQuery",
+      "content-type": "application/x-www-form-urlencoded"
+    },
+    method: "POST"
+  });
+  if (!response.ok) {
+    return null;
+  }
+  const payload = await response.json().catch(() => null);
+  const data = object(payload) && object(payload.data) ? payload.data : null;
+  return data ? gqlShortcodeMedia(data) : null;
+}
+async function graphqlParams(net, code) {
+  const response = await net(`https://www.instagram.com/p/${code}/`, {
+    headers: embedHeaders()
+  });
+  if (!response.ok) {
+    return null;
+  }
+  const html = await response.text();
+  const site = entryObject("SiteData", html);
+  const polaris = entryObject("PolarisSiteData", html);
+  const web = entryObject("DGWWebConfig", html);
+  const push = entryObject("InstagramWebPushInfo", html);
+  const lsd = entryObject("LSD", html)?.token ?? randomToken();
+  const csrf = entryObject("InstagramSecurityConfig", html)?.csrf_token;
+  const cookie = [
+    csrf && `csrftoken=${csrf}`,
+    polaris?.device_id && `ig_did=${polaris.device_id}`,
+    polaris?.machine_id && `mid=${polaris.machine_id}`,
+    "wd=1280x720",
+    "dpr=2",
+    "ig_nrcb=1"
+  ].filter((value) => typeof value === "string" && value.length > 0).join("; ");
+  return {
+    headers: {
+      "X-CSRFToken": string(csrf) ?? "",
+      "X-FB-LSD": string(lsd) ?? randomToken(),
+      "X-Bloks-Version-Id": string(entryObject("WebBloksVersioningID", html)?.versioningID) ?? "",
+      cookie,
+      "x-asbd-id": "129477",
+      "x-ig-app-id": string(web?.appId) ?? appId
+    },
+    body: {
+      __a: "1",
+      __ccg: "EXCELLENT",
+      __comet_req: String(queryNumber("__comet_req", html) ?? 7),
+      __csr: randomToken(154),
+      __d: "www",
+      __dyn: randomToken(154),
+      __hs: string(site?.haste_session) ?? "20126.HYP:instagram_web_pkg.2.1...0",
+      __hsi: string(site?.hsi) ?? "7436540909012459023",
+      __req: "b",
+      __rev: string(push?.rollout_hash) ?? "1019933358",
+      __s: `::${Math.random().toString(36).replace(/\d/g, "").slice(2, 8)}`,
+      __spin_b: string(site?.__spin_b) ?? "trunk",
+      __spin_r: string(site?.__spin_r) ?? "1019933358",
+      __spin_t: String(number(site?.__spin_t) ?? Math.floor(Date.now() / 1000)),
+      __user: "0",
+      av: "0",
+      dpr: "2",
+      jazoest: String(queryNumber("jazoest", html) ?? Math.floor(Math.random() * 1e4)),
+      lsd: string(lsd) ?? randomToken()
+    }
+  };
+}
+function gqlShortcodeMedia(data) {
+  const media = data.gql_data && object(data.gql_data) ? data.gql_data.shortcode_media ?? data.gql_data.xdt_shortcode_media : data.shortcode_media ?? data.xdt_shortcode_media;
+  return object(media) ? media : null;
+}
+function mediaItems(media, code, preferredWidth) {
+  const sidecar = object(media.edge_sidecar_to_children) && Array.isArray(media.edge_sidecar_to_children.edges) ? media.edge_sidecar_to_children.edges : [];
+  const oldItems = sidecar.flatMap((edge, index) => {
+    const node = object(edge) && object(edge.node) ? edge.node : null;
+    return node ? instagramItem(node, code, index + 1, preferredWidth) : [];
+  });
+  if (oldItems.length > 0) {
+    return oldItems;
+  }
+  const carousel = Array.isArray(media.carousel_media) ? media.carousel_media.filter(object) : [];
+  const newItems = carousel.flatMap((item, index) => instagramItem(item, code, index + 1, preferredWidth));
+  if (newItems.length > 0) {
+    return newItems;
+  }
+  return instagramItem(media, code, null, preferredWidth);
+}
+function instagramItem(media, code, index, preferredWidth) {
+  const video = selectVersion(media.video_versions, preferredWidth) ?? string(media.video_url);
+  const suffix = index === null ? "" : `_${index}`;
+  if (video) {
+    return [{
+      filename: filename(`instagram_${code}${suffix}.mp4`),
+      headers: { "user-agent": browserUserAgent() },
+      id: code,
+      kind: "video",
+      mime: "video/mp4",
+      platform: "instagram",
+      url: video
+    }];
+  }
+  const image = selectImage(media);
+  return image ? [{
+    filename: filename(`instagram_${code}${suffix}.jpg`),
+    headers: { "user-agent": browserUserAgent() },
+    id: code,
+    kind: "image",
+    mime: "image/jpeg",
+    platform: "instagram",
+    url: image
+  }] : [];
+}
+function selectImage(media) {
+  const imageVersions = object(media.image_versions2) && Array.isArray(media.image_versions2.candidates) ? media.image_versions2.candidates.filter(object) : [];
+  const first = imageVersions[0] ? string(imageVersions[0].url) : null;
+  return first ?? string(media.display_url);
+}
+function selectVersion(value, preferredWidth) {
+  const versions = Array.isArray(value) ? value.filter(object) : [];
+  const best = versions.reduce((current, candidate) => {
+    const width = number(candidate.width);
+    const currentWidth = current ? number(current.width) : null;
+    if (width === null) {
+      return current;
+    }
+    if (currentWidth === null) {
+      return candidate;
+    }
+    return Math.abs(width - preferredWidth) < Math.abs(currentWidth - preferredWidth) ? candidate : current;
+  }, null);
+  const selected = best ?? versions[0] ?? null;
+  return selected ? string(selected.url) : null;
+}
+function entryObject(name, html) {
+  const raw = html.match(new RegExp(`\\\\["${name}",.*?,({.*?}),\\\\d+\\\\]`))?.[1];
+  if (!raw) {
+    return null;
+  }
+  const parsed = JSON.parse(raw);
+  return object(parsed) ? parsed : null;
+}
+function queryNumber(name, html) {
+  const raw = html.match(new RegExp(`${name}=(\\d+)`))?.[1];
+  const parsed = raw ? Number(raw) : NaN;
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function randomToken(length = 8) {
+  return crypto.getRandomValues(new Uint8Array(length)).reduce((value, byte) => value + (byte % 36).toString(36), "");
+}
+
+// src/tiktok.ts
+var marker = '<script id="__UNIVERSAL_DATA_FOR_REHYDRATION__" type="application/json">';
+async function resolveTiktok(input) {
+  const userAgent = browserUserAgent();
+  const pageUrl = await followShortlink(input.net, userAgent, input.url);
+  const id = videoId(pageUrl);
+  if (!id) {
+    throw new Error("TikTok video id not found");
+  }
+  const page = await fetchVideoPage(input.net, id, userAgent).catch((error) => {
+    if (!recoverablePageError(error)) {
+      throw error;
+    }
+    return fetchVideoPage(input.net, id, firefoxUserAgent());
+  });
+  const user = author(page.item) ?? username(pageUrl) ?? "i";
+  const headers = {
+    referer: `https://www.tiktok.com/@${encodeURIComponent(user)}/video/${encodeURIComponent(id)}`,
+    "user-agent": userAgent
+  };
+  if (page.cookie) {
+    headers.cookie = page.cookie;
+  }
+  const items = mediaItems2(page.item, user, id, headers);
+  if (items.length === 0) {
+    throw new Error("TikTok media not found");
+  }
+  return { archiveFilename: filename(`tiktok_${user}_${id}.zip`), id, items, platform: "tiktok" };
+}
+async function fetchVideoPage(net, id, userAgent) {
+  const page = await net(`https://www.tiktok.com/@i/video/${id}`, {
+    headers: {
+      accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+      referer: "https://www.tiktok.com/",
+      "user-agent": userAgent
+    }
+  });
+  return { cookie: cookieHeader(page.headers), item: itemStruct(await page.text()) };
+}
+async function followShortlink(net, userAgent, input) {
+  const url = asUrl(input);
+  if (!url.hostname.includes("vt.tiktok.com")) {
+    return input;
+  }
+  const response = await net(input, { headers: { "user-agent": userAgent }, redirect: "manual" }, 1);
+  const location = response.headers.get("location");
+  if (location) {
+    return new URL(location, input).href;
+  }
+  const html = await response.text();
+  const href = html.match(/<a href="(https:\/\/[^"]+)"/)?.[1];
+  return href ? new URL(href.split("?")[0]).href : input;
+}
+function videoId(input) {
+  return asUrl(input).pathname.match(/video\/(\d+)/)?.[1] ?? null;
+}
+function itemStruct(html) {
+  if (html.includes("SlardarWAF") || html.includes("_wafchallengeid")) {
+    throw new Error("TikTok WAF challenge");
+  }
+  const start = html.indexOf(marker);
+  const end = start === -1 ? -1 : html.indexOf("</script>", start + marker.length);
+  if (start === -1 || end === -1) {
+    throw new Error("TikTok hydration not found");
+  }
+  const parsed = JSON.parse(html.slice(start + marker.length, end));
+  const scope = object(parsed) && object(parsed.__DEFAULT_SCOPE__) ? parsed.__DEFAULT_SCOPE__ : null;
+  const detail = scope && object(scope["webapp.video-detail"]) ? scope["webapp.video-detail"] : null;
+  const info = detail && object(detail.itemInfo) ? detail.itemInfo : null;
+  const item = info && object(info.itemStruct) ? info.itemStruct : null;
+  if (!item) {
+    throw new Error("TikTok itemStruct not found");
+  }
+  return item;
+}
+function recoverablePageError(error) {
+  const message = error instanceof Error ? error.message : "";
+  return message === "TikTok WAF challenge" || message === "TikTok hydration not found";
+}
+function downloadUrl(item) {
+  const video = object(item.video) ? item.video : null;
+  return video ? string(video.playAddr) ?? string(video.downloadAddr) : null;
+}
+function mediaItems2(item, user, id, headers) {
+  const images = imageItems(item, user, id, headers);
+  if (images.length > 0) {
+    const audio = audioItem(item, user, id, headers);
+    return audio ? [...images, audio] : images;
+  }
+  const url = downloadUrl(item);
+  return url ? [{
+    filename: filename(`tiktok_${user}_${id}.mp4`),
+    headers,
+    id,
+    kind: "video",
+    mime: "video/mp4",
+    platform: "tiktok",
+    url
+  }] : [];
+}
+function imageItems(item, user, id, headers) {
+  const imagePost = object(item.imagePost) ? item.imagePost : null;
+  const images = imagePost && Array.isArray(imagePost.images) ? imagePost.images.filter(object) : [];
+  return images.flatMap((image, index) => {
+    const imageUrl = object(image.imageURL) ? image.imageURL : null;
+    const list = imageUrl && Array.isArray(imageUrl.urlList) ? imageUrl.urlList : [];
+    const url = list.map(string).find((candidate) => Boolean(candidate)) ?? null;
+    return url ? [{
+      filename: filename(`tiktok_${user}_${id}_${index + 1}.jpg`),
+      headers,
+      id,
+      kind: "image",
+      mime: "image/jpeg",
+      platform: "tiktok",
+      url
+    }] : [];
+  });
+}
+function audioItem(item, user, id, headers) {
+  const video = object(item.video) ? item.video : null;
+  const music = object(item.music) ? item.music : null;
+  const url = video ? string(video.playAddr) : null;
+  const fallback = music ? string(music.playUrl) : null;
+  const selected = url ?? fallback;
+  if (!selected) {
+    return null;
+  }
+  const extension = selected.includes("mime_type=audio_mpeg") ? "mp3" : "m4a";
+  return {
+    filename: filename(`tiktok_${user}_${id}_audio.${extension}`),
+    headers,
+    id,
+    kind: "audio",
+    mime: extension === "mp3" ? "audio/mpeg" : "audio/mp4",
+    platform: "tiktok",
+    url: selected
+  };
+}
+function author(item) {
+  const user = object(item.author) ? item.author : null;
+  return user ? string(user.uniqueId) : null;
+}
+function username(input) {
+  return asUrl(input).pathname.match(/@([^/]+)/)?.[1] ?? null;
+}
+function cookieHeader(headers) {
+  const getter = headers.getSetCookie;
+  const setCookie = typeof getter === "function" ? getter.call(headers).join(",") : headers.get("set-cookie");
+  const cookies = setCookie?.split(/,(?=[^;]+?=)/).map((part) => part.split(";")[0]?.trim()).filter((part) => Boolean(part));
+  return cookies && cookies.length > 0 ? cookies.join("; ") : null;
+}
+
+// src/twitter.ts
+async function resolveTwitter(input) {
+  const id = tweetId(input.url);
+  if (!id) {
+    throw new Error("Tweet id not found");
+  }
+  const tweet = await syndication(input.net, id);
+  if (string(tweet.__typename) === "TweetTombstone") {
+    throw new Error("Tweet is unavailable or age-restricted");
+  }
+  const media = Array.isArray(tweet.mediaDetails) ? tweet.mediaDetails.filter(object) : [];
+  const items = media.flatMap((entry, index) => twitterItem(entry, id, index + 1));
+  if (items.length === 0) {
+    throw new Error("Twitter media not found");
+  }
+  return { archiveFilename: filename(`twitter_${id}.zip`), id, items, platform: "twitter" };
+}
+async function syndication(net, id) {
+  const url = `https://cdn.syndication.twimg.com/tweet-result?id=${id}&lang=en&token=${syndicationToken(id)}`;
+  const response = await net(url, { headers: { accept: "application/json", "user-agent": browserUserAgent() } });
+  if (!response.ok) {
+    throw new Error(`Twitter syndication failed: ${response.status}`);
+  }
+  const payload = await response.json();
+  if (!object(payload)) {
+    throw new Error("Twitter response invalid");
+  }
+  return payload;
+}
+function syndicationToken(id) {
+  return (Number(id) / 1000000000000000 * Math.PI).toString(36).replace(/(0+|\.)/g, "");
+}
+function twitterItem(entry, id, index) {
+  const headers = { "user-agent": browserUserAgent() };
+  const type = string(entry.type);
+  if (type === "video" || type === "animated_gif") {
+    const url = bestVariant(entry);
+    return url ? [{ filename: filename(`twitter_${id}_${index}.mp4`), headers, id, kind: "video", mime: "video/mp4", platform: "twitter", url }] : [];
+  }
+  const photo = string(entry.media_url_https);
+  return photo ? [{ filename: filename(`twitter_${id}_${index}.jpg`), headers, id, kind: "image", mime: "image/jpeg", platform: "twitter", url: `${photo}?name=orig` }] : [];
+}
+function bestVariant(entry) {
+  const info = object(entry.video_info) ? entry.video_info : null;
+  const variants = info && Array.isArray(info.variants) ? info.variants.filter(object) : [];
+  const best = variants.filter((variant) => string(variant.content_type) === "video/mp4").reduce((current, variant) => {
+    const bitrate = number(variant.bitrate) ?? 0;
+    const currentBitrate = current ? number(current.bitrate) ?? 0 : -1;
+    return bitrate > currentBitrate ? variant : current;
+  }, null);
+  return best ? string(best.url) : null;
+}
+function tweetId(input) {
+  return asUrl(input).pathname.match(/\/status(?:es)?\/(\d+)/)?.[1] ?? null;
+}
+
+// src/youtube.ts
+var androidVrClient = {
+  name: "ANDROID_VR",
+  number: "28",
+  userAgent: "com.google.android.apps.youtube.vr.oculus/1.65.10 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip",
+  version: "1.65.10"
+};
+var browserCookie = "PREF=hl=en&tz=UTC; SOCS=CAI";
+async function resolveYoutube(input) {
+  const id = youtubeVideoId(input.url);
+  if (!id) {
+    throw new Error("YouTube video id not found");
+  }
+  const session = await youtubeSession(input.net, id);
+  const response = await input.net("https://www.youtube.com/youtubei/v1/player?prettyPrint=false", {
+    body: JSON.stringify(playerBody(id, session)),
+    headers: playerHeaders(session),
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error(`YouTube player failed: ${response.status}`);
+  }
+  const payload = await response.json();
+  const status = object(payload) && object(payload.playabilityStatus) ? string(payload.playabilityStatus.status) : null;
+  if (status !== "OK") {
+    const reason = object(payload) && object(payload.playabilityStatus) ? string(payload.playabilityStatus.reason) : null;
+    throw new Error(reason ?? "YouTube video unavailable");
+  }
+  const format = selectFormat(payload);
+  if (!format) {
+    throw new Error("YouTube progressive mp4 not found");
+  }
+  const title = object(payload) && object(payload.videoDetails) ? string(payload.videoDetails.title) : null;
+  const media = {
+    filename: filename(`youtube_${title ?? id}_${id}.mp4`),
+    headers: { "user-agent": androidVrClient.userAgent },
+    id,
+    kind: "video",
+    mime: "video/mp4",
+    platform: "youtube",
+    url: format
+  };
+  return { archiveFilename: filename(`youtube_${id}.zip`), id, items: [media], platform: "youtube" };
+}
+function playerBody(id, session) {
+  return {
+    contentCheckOk: true,
+    context: {
+      client: {
+        androidSdkVersion: 32,
+        clientName: androidVrClient.name,
+        clientVersion: androidVrClient.version,
+        deviceMake: "Oculus",
+        deviceModel: "Quest 3",
+        gl: "US",
+        hl: "en",
+        osName: "Android",
+        osVersion: "12L",
+        timeZone: "UTC",
+        userAgent: androidVrClient.userAgent,
+        utcOffsetMinutes: 0,
+        visitorData: session.visitorData
+      }
+    },
+    playbackContext: {
+      contentPlaybackContext: {
+        html5Preference: "HTML5_PREF_WANTS",
+        signatureTimestamp: session.signatureTimestamp
+      }
+    },
+    racyCheckOk: true,
+    videoId: id
+  };
+}
+async function youtubeSession(net, id) {
+  const response = await net(`https://www.youtube.com/watch?v=${id}&bpctr=9999999999&has_verified=1`, {
+    headers: {
+      accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "accept-language": "en-us,en;q=0.5",
+      cookie: browserCookie,
+      "sec-fetch-mode": "navigate",
+      "user-agent": browserUserAgent()
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`YouTube page failed: ${response.status}`);
+  }
+  const page = await response.text();
+  const visitorData = string(page.match(/"visitorData":"([^"]+)"/)?.[1]);
+  if (!visitorData) {
+    throw new Error("YouTube visitor data not found");
+  }
+  const playerPath = string(page.match(/"jsUrl":"([^"]+)"/)?.[1]) ?? string(page.match(/"PLAYER_JS_URL":"([^"]+)"/)?.[1]);
+  if (!playerPath) {
+    throw new Error("YouTube player url not found");
+  }
+  return {
+    cookie: youtubeCookie(response.headers),
+    signatureTimestamp: await signatureTimestamp(net, playerPath),
+    visitorData
+  };
+}
+function playerHeaders(session) {
+  return new Headers({
+    "content-type": "application/json",
+    cookie: `${browserCookie}; ${session.cookie}`,
+    origin: "https://www.youtube.com",
+    "user-agent": androidVrClient.userAgent,
+    "x-goog-visitor-id": session.visitorData,
+    "x-youtube-client-name": androidVrClient.number,
+    "x-youtube-client-version": androidVrClient.version
+  });
+}
+function youtubeCookie(headers) {
+  const readable = headers;
+  const fallback = headers.get("set-cookie");
+  const cookieHeaders = readable.getSetCookie ? readable.getSetCookie() : fallback ? [fallback] : [];
+  return cookieHeaders.map((header) => string(header.split(";", 1)[0])).filter(string).join("; ");
+}
+async function signatureTimestamp(net, playerPath) {
+  const response = await net(new URL(playerPath, "https://www.youtube.com").toString(), {
+    headers: { "user-agent": browserUserAgent() }
+  });
+  if (!response.ok) {
+    throw new Error(`YouTube player failed: ${response.status}`);
+  }
+  const player = await response.text();
+  const timestamp = number(Number(player.match(/signatureTimestamp[:=](\d+)/)?.[1] ?? player.match(/sts[:=](\d+)/)?.[1]));
+  if (!timestamp) {
+    throw new Error("YouTube signature timestamp not found");
+  }
+  return timestamp;
+}
+function youtubeVideoId(input) {
+  const url = asUrl(input);
+  if (url.hostname === "youtu.be") {
+    return cleanId(url.pathname.split("/").filter(Boolean)[0]);
+  }
+  const fromQuery = cleanId(url.searchParams.get("v"));
+  if (fromQuery) {
+    return fromQuery;
+  }
+  const parts = url.pathname.split("/").filter(Boolean);
+  const index = parts.findIndex((part) => part === "shorts" || part === "live" || part === "embed");
+  return index >= 0 ? cleanId(parts[index + 1]) : null;
+}
+function cleanId(value) {
+  return typeof value === "string" && /^[A-Za-z0-9_-]{11}$/.test(value) ? value : null;
+}
+function selectFormat(payload) {
+  const root = object(payload) ? payload : null;
+  const streaming = root && object(root.streamingData) ? root.streamingData : null;
+  const formats = streaming && Array.isArray(streaming.formats) ? streaming.formats.filter(object) : [];
+  const mp4 = formats.filter((format) => string(format.url) && string(format.mimeType)?.startsWith("video/mp4")).sort((left, right) => height(right) - height(left));
+  return mp4[0] ? string(mp4[0].url) : null;
+}
+function height(format) {
+  return number(format.height) ?? Number(string(format.qualityLabel)?.match(/(\d+)p/)?.[1] ?? 0);
+}
+
+// src/postfetch.ts
+async function postfetch(url, options = {}) {
+  const trimmed = url.trim();
+  if (trimmed.length === 0) {
+    throw new PostfetchError(400, "url is required");
+  }
+  const context = {
+    net: createNet(options.fetch ?? globalThis.fetch),
+    preferredWidth: options.preferredWidth ?? 720,
+    url: trimmed
+  };
+  switch (detect(trimmed)) {
+    case "facebook":
+      return resolveFacebook(context);
+    case "instagram":
+      return resolveInstagram(context);
+    case "tiktok":
+      return resolveTiktok(context);
+    case "twitter":
+      return resolveTwitter(context);
+    case "youtube":
+      return resolveYoutube(context);
+  }
+}
+function detect(url) {
+  const host = asUrl(url).hostname;
+  if (host.includes("tiktok.com")) {
+    return "tiktok";
+  }
+  if (host.includes("instagram.com")) {
+    return "instagram";
+  }
+  if (host.includes("youtube.com") || host === "youtu.be") {
+    return "youtube";
+  }
+  if (host.includes("facebook.com") || host === "fb.watch") {
+    return "facebook";
+  }
+  if (host === "x.com" || host.endsWith(".x.com") || host.includes("twitter.com")) {
+    return "twitter";
+  }
+  throw new PostfetchError(400, "only Facebook, Instagram, TikTok, X and YouTube URLs are supported");
+}
+// src/zip.ts
+var encoder = new TextEncoder;
+var table = new Uint32Array(256);
+for (let value = 0;value < table.length; value += 1) {
+  let crc = value;
+  for (let bit = 0;bit < 8; bit += 1) {
+    crc = crc & 1 ? 3988292384 ^ crc >>> 1 : crc >>> 1;
+  }
+  table[value] = crc >>> 0;
+}
+function zip(entries) {
+  const files = entries.map((entry) => {
+    const name = encoder.encode(entry.name);
+    const crc = crc32(entry.data);
+    return { ...entry, crc, name };
+  });
+  const locals = files.map((file) => 30 + file.name.length + file.data.length);
+  const centrals = files.map((file) => 46 + file.name.length);
+  const localSize = locals.reduce((sum, size) => sum + size, 0);
+  const centralSize = centrals.reduce((sum, size) => sum + size, 0);
+  const result = new Uint8Array(localSize + centralSize + 22);
+  const view = new DataView(result.buffer);
+  let offset = 0;
+  const centralOffsets = [];
+  for (const file of files) {
+    centralOffsets.push(offset);
+    offset = writeLocal(view, result, offset, file);
+  }
+  const centralStart = offset;
+  for (let index = 0;index < files.length; index += 1) {
+    offset = writeCentral(view, result, offset, files[index], centralOffsets[index]);
+  }
+  writeEnd(view, offset, files.length, centralSize, centralStart);
+  return result;
+}
+function writeLocal(view, target, offset, file) {
+  view.setUint32(offset, 67324752, true);
+  view.setUint16(offset + 4, 20, true);
+  view.setUint16(offset + 6, 2048, true);
+  view.setUint16(offset + 8, 0, true);
+  writeDate(view, offset + 10);
+  view.setUint32(offset + 14, file.crc, true);
+  view.setUint32(offset + 18, file.data.length, true);
+  view.setUint32(offset + 22, file.data.length, true);
+  view.setUint16(offset + 26, file.name.length, true);
+  view.setUint16(offset + 28, 0, true);
+  target.set(file.name, offset + 30);
+  target.set(file.data, offset + 30 + file.name.length);
+  return offset + 30 + file.name.length + file.data.length;
+}
+function writeCentral(view, target, offset, file, localOffset) {
+  view.setUint32(offset, 33639248, true);
+  view.setUint16(offset + 4, 20, true);
+  view.setUint16(offset + 6, 20, true);
+  view.setUint16(offset + 8, 2048, true);
+  view.setUint16(offset + 10, 0, true);
+  writeDate(view, offset + 12);
+  view.setUint32(offset + 16, file.crc, true);
+  view.setUint32(offset + 20, file.data.length, true);
+  view.setUint32(offset + 24, file.data.length, true);
+  view.setUint16(offset + 28, file.name.length, true);
+  view.setUint16(offset + 30, 0, true);
+  view.setUint16(offset + 32, 0, true);
+  view.setUint16(offset + 34, 0, true);
+  view.setUint16(offset + 36, 0, true);
+  view.setUint32(offset + 38, 0, true);
+  view.setUint32(offset + 42, localOffset, true);
+  target.set(file.name, offset + 46);
+  return offset + 46 + file.name.length;
+}
+function writeEnd(view, offset, count, centralSize, centralStart) {
+  view.setUint32(offset, 101010256, true);
+  view.setUint16(offset + 8, count, true);
+  view.setUint16(offset + 10, count, true);
+  view.setUint32(offset + 12, centralSize, true);
+  view.setUint32(offset + 16, centralStart, true);
+}
+function writeDate(view, offset) {
+  const date = new Date;
+  const time = date.getHours() << 11 | date.getMinutes() << 5 | Math.floor(date.getSeconds() / 2);
+  const day = date.getFullYear() - 1980 << 9 | date.getMonth() + 1 << 5 | date.getDate();
+  view.setUint16(offset, time, true);
+  view.setUint16(offset + 2, day, true);
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (const byte of data) {
+    crc = table[(crc ^ byte) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/download.ts
+async function download(item, options = {}) {
+  const net = createNet(options.fetch ?? globalThis.fetch);
+  const response = await net(item.url, { headers: item.headers });
+  if (!response.ok || !response.body) {
+    throw new PostfetchError(502, `download failed: ${response.status}`);
+  }
+  return response;
+}
+async function archive(result, options = {}) {
+  const net = createNet(options.fetch ?? globalThis.fetch);
+  const files = await Promise.all(result.items.map(async (item) => {
+    const response = await net(item.url, { headers: item.headers });
+    if (!response.ok) {
+      throw new PostfetchError(502, `download failed: ${response.status}`);
+    }
+    return { data: new Uint8Array(await response.arrayBuffer()), name: item.filename };
+  }));
+  return { bytes: zip(files), filename: result.archiveFilename, mime: "application/zip" };
+}
+async function toResponse(result, options = {}) {
+  if (result.items.length === 1) {
+    return singleResponse(result.items[0], options);
+  }
+  return archiveResponse(result, options);
+}
+async function singleResponse(item, options) {
+  const media = await download(item, options);
+  const headers = new Headers({
+    "content-disposition": `attachment; filename="${item.filename}"`,
+    "content-type": media.headers.get("content-type") ?? item.mime,
+    "x-media-count": "1",
+    "x-media-id": item.id,
+    "x-media-kind": item.kind,
+    "x-media-platform": item.platform
+  });
+  const length = media.headers.get("content-length");
+  if (length) {
+    headers.set("content-length", length);
+  }
+  return new Response(media.body, { headers });
+}
+async function archiveResponse(result, options) {
+  const { bytes, filename: filename2 } = await archive(result, options);
+  const body = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  return new Response(body, {
+    headers: {
+      "content-disposition": `attachment; filename="${filename2}"`,
+      "content-length": String(bytes.length),
+      "content-type": "application/zip",
+      "x-media-count": String(result.items.length),
+      "x-media-id": result.id,
+      "x-media-platform": result.platform
+    }
+  });
+}
+export {
+  toResponse,
+  postfetch,
+  download,
+  detect,
+  archive,
+  PostfetchError
+};