@postfetch/core 0.5.2 → 0.7.0

package/dist/index.js

@@ -124,20 +124,25 @@ function browserFingerprint() {
     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();
+function baseNavigationHeaders(userAgent, acceptLanguage) {
   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,
+    "accept-language": acceptLanguage,
     "sec-fetch-dest": "document",
     "sec-fetch-mode": "navigate",
     "sec-fetch-site": "none",
     "sec-fetch-user": "?1",
     "upgrade-insecure-requests": "1",
-    "user-agent": fingerprint.userAgent
+    "user-agent": userAgent
+  };
+}
+function navigationHeaders() {
+  const fingerprint = browserFingerprint();
+  return {
+    ...baseNavigationHeaders(fingerprint.userAgent, fingerprint.acceptLanguage),
+    "sec-ch-ua": fingerprint.secChUa,
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": fingerprint.secChUaPlatform
   };
 }
 function browserUserAgent() {
@@ -148,19 +153,22 @@ function firefoxUserAgent() {
   const version = pick(firefoxVersions);
   return `Mozilla/5.0 (${platform.uaToken}; rv:${version}.0) Gecko/20100101 Firefox/${version}.0`;
 }
+function firefoxNavigationHeaders(userAgent = firefoxUserAgent()) {
+  return baseNavigationHeaders(userAgent, pick(acceptLanguages));
+}
 function instagramAppUserAgent() {
   return pick(instagramAppUserAgents);
 }
 
 // src/facebook.ts
 async function resolveFacebook(input) {
-  const canonical = await canonicalUrl(input.net, input.url);
+  const canonical = await canonicalUrl(input.net, normalizedInputUrl(input.url));
   const id = facebookId(canonical) ?? facebookId(input.url) ?? "video";
-  const embed = await embedVideo(input.net, canonical);
-  const watch = !embed && /^\d+$/.test(id) ? await watchVideo(input.net, id) : null;
+  const embed = await embedVideo(input.net, canonical, input.preferredWidth);
+  const watch = !embed && /^\d+$/.test(id) ? await watchVideo(input.net, id, input.preferredWidth) : null;
   const url = embed ?? watch?.url ?? null;
   if (!url) {
-    throw new Error("Facebook video not found");
+    throw new PostfetchError(404, "Facebook video not found", "notFound");
   }
   const item = {
     filename: filename(`facebook_${id}.mp4`),
@@ -173,6 +181,11 @@ async function resolveFacebook(input) {
   };
   return { archiveFilename: filename(`facebook_${id}.zip`), id, items: [item], metadata: watch?.metadata, platform: "facebook" };
 }
+function normalizedInputUrl(input) {
+  const url = asUrl(input);
+  const share = url.pathname.match(/^\/share\/([a-z])\/([A-Za-z0-9]+)/i);
+  return share ? `${url.origin}/share/${share[1]}/${share[2]}/` : input;
+}
 function navigationHeaders2() {
   return {
     "accept-language": "en-US,en;q=0.9",
@@ -185,25 +198,30 @@ async function canonicalUrl(net, input) {
   const resolved = asUrl(response.url);
   return `${resolved.origin}${resolved.pathname}`;
 }
-async function embedVideo(net, canonical) {
+async function embedVideo(net, canonical, preferredWidth) {
   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");
+  return preferredSource(preferredWidth, source(html, "hd_src"), source(html, "sd_src"));
 }
-async function watchVideo(net, id) {
+async function watchVideo(net, id, preferredWidth) {
   const headers = { ...navigationHeaders2(), accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" };
   const response = await net(`https://www.facebook.com/watch/?v=${id}&_rdr`, { headers });
   if (!response.ok) {
     return null;
   }
   const html = await response.text();
-  const url = source(html, "playable_url_quality_hd") ?? source(html, "browser_native_hd_url") ?? source(html, "playable_url") ?? source(html, "browser_native_sd_url");
+  const hd = source(html, "playable_url_quality_hd") ?? source(html, "browser_native_hd_url");
+  const sd = source(html, "playable_url") ?? source(html, "browser_native_sd_url");
+  const url = preferredSource(preferredWidth, hd, sd);
   return url ? { url, metadata: watchMetadata(html) } : null;
 }
+function preferredSource(preferredWidth, hd, sd) {
+  return preferredWidth >= 540 ? hd ?? sd : sd ?? hd;
+}
 function watchMetadata(html) {
   const owner = html.match(/"name":("(?:\\.|[^"\\])*"),"__isVideoOwner"/);
   const name = owner ? JSON.parse(owner[1]) : undefined;
@@ -271,7 +289,21 @@ function embedHeaders() {
 }
 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);
+  const videoRequired = /\/(?:reel|reels|tv)\//.test(asUrl(input.url).pathname);
+  const resolvers = [
+    () => pageMedia(input.net, code, input.preferredWidth),
+    () => mobileMedia(input.net, code, input.preferredWidth),
+    () => embedMedia(input.net, code),
+    () => graphqlMedia(input.net, code)
+  ];
+  let media = null;
+  for (const resolve of resolvers) {
+    const candidate = await resolve();
+    if (candidate && (!videoRequired || mediaItems(candidate, code, input.preferredWidth).some((item) => item.kind === "video"))) {
+      media = candidate;
+      break;
+    }
+  }
   if (!media) {
     throw await instagramUnavailable(input.net, code);
   }
@@ -481,23 +513,20 @@ async function graphqlMedia(net, code) {
   }
   const body = new URLSearchParams({
     ...params.body,
-    doc_id: "8845758582119845",
+    av: "0",
+    doc_id: "26130443479876713",
     fb_api_caller_class: "RelayModern",
-    fb_api_req_friendly_name: "PolarisPostActionLoadPostQueryQuery",
+    fb_api_req_friendly_name: "PolarisPostRootQuery",
     server_timestamps: "true",
-    variables: JSON.stringify({
-      fetch_tagged_user_count: null,
-      hoisted_comment_id: null,
-      hoisted_reply_id: null,
-      shortcode: code
-    })
+    variables: JSON.stringify({ shortcode: code })
   });
   const response = await net("https://www.instagram.com/graphql/query", {
     body,
     headers: {
       ...embedHeaders(),
       ...params.headers,
-      "X-FB-Friendly-Name": "PolarisPostActionLoadPostQueryQuery",
+      "X-FB-Friendly-Name": "PolarisPostRootQuery",
+      "X-Requested-With": "XMLHttpRequest",
       "content-type": "application/x-www-form-urlencoded"
     },
     method: "POST"
@@ -523,14 +552,14 @@ async function graphqlParams(net, code) {
   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("; ");
+  const cookie = instagramCookies(response.headers, {
+    csrftoken: string(csrf),
+    dpr: "2",
+    ig_did: string(polaris?.device_id),
+    ig_nrcb: "1",
+    mid: string(polaris?.machine_id),
+    wd: "1280x720"
+  });
   return {
     headers: {
       "X-CSRFToken": string(csrf) ?? "",
@@ -564,6 +593,12 @@ async function graphqlParams(net, code) {
   };
 }
 function gqlShortcodeMedia(data) {
+  const webInfo = object(data.xdt_api__v1__media__shortcode__web_info) ? data.xdt_api__v1__media__shortcode__web_info : null;
+  const webItems = webInfo && Array.isArray(webInfo.items) ? webInfo.items : [];
+  const webMedia = webItems[0];
+  if (object(webMedia)) {
+    return webMedia;
+  }
   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;
 }
@@ -583,6 +618,24 @@ function mediaItems(media, code, preferredWidth) {
   }
   return instagramItem(media, code, null, preferredWidth);
 }
+function instagramCookies(headers, fallback) {
+  const getter = headers.getSetCookie;
+  const raw = typeof getter === "function" ? getter.call(headers) : headers.get("set-cookie")?.split(/,(?=[^;]+?=)/) ?? [];
+  const cookies = new Map;
+  for (const value of raw) {
+    const pair = value.split(";", 1)[0]?.trim();
+    const separator = pair?.indexOf("=") ?? -1;
+    if (pair && separator > 0) {
+      cookies.set(pair.slice(0, separator), pair.slice(separator + 1));
+    }
+  }
+  for (const [name, value] of Object.entries(fallback)) {
+    if (value && !cookies.has(name)) {
+      cookies.set(name, value);
+    }
+  }
+  return [...cookies].map(([name, value]) => `${name}=${value}`).join("; ");
+}
 function instagramItem(media, code, index, preferredWidth) {
   const video = selectVersion(media.video_versions, preferredWidth) ?? string(media.video_url);
   const suffix = index === null ? "" : `_${index}`;
@@ -646,6 +699,208 @@ function randomToken(length = 8) {
   return crypto.getRandomValues(new Uint8Array(length)).reduce((value, byte) => value + (byte % 36).toString(36), "");
 }
 
+// src/linkedin.ts
+async function resolveLinkedin(input) {
+  const reference = postReference(input.url);
+  const pageUrl = `https://www.linkedin.com/feed/update/urn:li:${reference.kind}:${reference.id}`;
+  const response = await input.net(pageUrl, { headers: navigationHeaders() });
+  if (response.status === 404) {
+    throw new PostfetchError(404, "LinkedIn post not found", "notFound");
+  }
+  if (response.status === 429 || response.status === 999) {
+    throw new PostfetchError(429, "LinkedIn rate limit reached", "rateLimited");
+  }
+  if (!response.ok) {
+    throw new PostfetchError(response.status, "LinkedIn post unavailable", "unavailable");
+  }
+  if (response.url.includes("/signup/") || response.url.includes("/login")) {
+    throw new PostfetchError(401, "LinkedIn login required", "loginRequired");
+  }
+  const html = await response.text();
+  const post = linkedinPost(html);
+  if (!post) {
+    throw new PostfetchError(404, "LinkedIn post unavailable", "unavailable");
+  }
+  const canonical = string(post["@id"]);
+  const canonicalReference = canonical ? postReferenceOrNull(canonical) : null;
+  const id = canonicalReference?.id ?? reference.id;
+  const items = linkedinItems(post, html, id, pageUrl);
+  if (items.length === 0) {
+    throw new Error("LinkedIn media url not found");
+  }
+  return {
+    archiveFilename: filename(`linkedin_${id}.zip`),
+    id,
+    items,
+    metadata: linkedinMetadata(post),
+    platform: "linkedin"
+  };
+}
+function linkedinMetadata(post) {
+  const author = linkedinAuthor(post);
+  return {
+    title: string(post.text) ?? string(post.name) ?? string(post.headline) ?? undefined,
+    text: string(post.description) ?? string(post.articleBody) ?? string(post.text) ?? undefined,
+    author: author ? {
+      handle: linkedinHandle(string(author.url)) ?? undefined,
+      name: string(author.name) ?? undefined
+    } : undefined,
+    createdAt: isoFromDateString(post.datePublished ?? post.uploadDate),
+    likeCount: interactionCount(post.interactionStatistic, "LikeAction"),
+    commentCount: count(post.commentCount) ?? interactionCount(post.interactionStatistic, "CommentAction")
+  };
+}
+function postReference(input) {
+  const reference = postReferenceOrNull(input);
+  if (!reference) {
+    throw new PostfetchError(400, "LinkedIn post id not found");
+  }
+  return reference;
+}
+function postReferenceOrNull(input) {
+  let pathname;
+  try {
+    pathname = new URL(input).pathname.replace(/%3A/gi, ":");
+  } catch {
+    return null;
+  }
+  const urn = pathname.match(/\/(?:embed\/)?feed\/update\/urn:li:(activity|share|ugcpost):(\d+)\/?$/i);
+  const post = pathname.match(/\/posts\/[^/]*-(activity|share|ugcpost)-(\d+)(?:-[^/]*)?\/?$/i);
+  const match = urn ?? post;
+  if (!match) {
+    return null;
+  }
+  switch (match[1].toLowerCase()) {
+    case "activity":
+      return { id: match[2], kind: "activity" };
+    case "share":
+      return { id: match[2], kind: "share" };
+    case "ugcpost":
+      return { id: match[2], kind: "ugcPost" };
+    default:
+      return null;
+  }
+}
+function linkedinAuthor(post) {
+  if (object(post.creator)) {
+    return post.creator;
+  }
+  if (object(post.author)) {
+    return post.author;
+  }
+  return null;
+}
+function linkedinPost(html) {
+  for (const match of html.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/gi)) {
+    if (!/\btype=["']application\/ld\+json["']/i.test(match[1])) {
+      continue;
+    }
+    const parsed = parseJson(match[2]);
+    for (const entry of jsonLdEntries(parsed)) {
+      if (hasSchemaType(entry, "VideoObject") || hasSchemaType(entry, "SocialMediaPosting")) {
+        return entry;
+      }
+    }
+  }
+  return null;
+}
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    try {
+      return JSON.parse(decodeHtml(value));
+    } catch {
+      return null;
+    }
+  }
+}
+function jsonLdEntries(value) {
+  if (Array.isArray(value)) {
+    return value.filter(object);
+  }
+  if (!object(value)) {
+    return [];
+  }
+  return Array.isArray(value["@graph"]) ? value["@graph"].filter(object) : [value];
+}
+function hasSchemaType(value, expected) {
+  const type = value["@type"];
+  return type === expected || Array.isArray(type) && type.includes(expected);
+}
+function linkedinItems(post, html, id, referer) {
+  const headers = { referer, "user-agent": browserUserAgent() };
+  if (hasSchemaType(post, "VideoObject")) {
+    const url2 = bestVideoUrl(html) ?? string(post.contentUrl);
+    return url2 ? [{ filename: filename(`linkedin_${id}.mp4`), headers, id, kind: "video", mime: "video/mp4", platform: "linkedin", url: url2 }] : [];
+  }
+  const url = imageUrl(post.image);
+  return url ? [{ filename: filename(`linkedin_${id}.jpg`), headers, id, kind: "image", mime: "image/jpeg", platform: "linkedin", url }] : [];
+}
+function bestVideoUrl(html) {
+  const encoded = html.match(/<video\b[^>]*\bdata-sources=(["'])(.*?)\1[^>]*>/is)?.[2];
+  if (!encoded) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(decodeHtml(encoded));
+  } catch {
+    return null;
+  }
+  const sources = Array.isArray(parsed) ? parsed.filter(object) : [];
+  const videos = sources.filter((source2) => string(source2.type) === "video/mp4" && string(source2.src));
+  const selected = videos.reduce((best, candidate) => {
+    const bitrate = count(candidate["data-bitrate"]) ?? 0;
+    const bestBitrate = best ? count(best["data-bitrate"]) ?? 0 : -1;
+    return bitrate > bestBitrate ? candidate : best;
+  }, null);
+  return selected ? string(selected.src) : null;
+}
+function imageUrl(value) {
+  if (typeof value === "string") {
+    return string(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(imageUrl).find((url) => Boolean(url)) ?? null;
+  }
+  return object(value) ? string(value.url) : null;
+}
+function interactionCount(value, action) {
+  const statistics = Array.isArray(value) ? value.filter(object) : object(value) ? [value] : [];
+  const statistic = statistics.find((entry) => string(entry.interactionType)?.endsWith(`/${action}`));
+  return statistic ? count(statistic.userInteractionCount) : undefined;
+}
+function linkedinHandle(value) {
+  if (!value) {
+    return null;
+  }
+  try {
+    return new URL(value).pathname.match(/^\/(?:company|in|showcase)\/([^/]+)/)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function decodeHtml(value) {
+  return value.replace(/&(quot|amp|lt|gt|#39|#x27|#(\d+)|#x([0-9a-f]+));/gi, (_entity, name, decimal, hex) => {
+    switch (name.toLowerCase()) {
+      case "quot":
+        return '"';
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "#39":
+      case "#x27":
+        return "'";
+      default:
+        return String.fromCodePoint(decimal ? Number.parseInt(decimal, 10) : Number.parseInt(hex, 16));
+    }
+  });
+}
+
 // src/isobmff.ts
 function parseBoxes(data, start = 0, end = data.length) {
   const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
@@ -1407,23 +1662,18 @@ function trackId(track) {
 
 // src/tiktok.ts
 var marker = '<script id="__UNIVERSAL_DATA_FOR_REHYDRATION__" type="application/json">';
+var pageAttemptCount = 12;
 async function resolveTiktok(input) {
-  const userAgent = browserUserAgent();
-  const pageUrl = await followShortlink(input.net, userAgent, input.url);
+  const pageUrl = await followShortlink(input.net, browserUserAgent(), 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 page = await videoPage(input.net, id, asUrl(pageUrl).pathname.includes("/photo/"));
   const user = author(page.item) ?? username(pageUrl) ?? "i";
   const headers = {
     referer: `https://www.tiktok.com/@${encodeURIComponent(user)}/video/${encodeURIComponent(id)}`,
-    "user-agent": userAgent
+    "user-agent": page.userAgent
   };
   if (page.cookie) {
     headers.cookie = page.cookie;
@@ -1434,6 +1684,35 @@ async function resolveTiktok(input) {
   }
   return { archiveFilename: filename(`tiktok_${user}_${id}.zip`), id, items, metadata: tiktokMetadata(page.item), platform: "tiktok" };
 }
+async function videoPage(net, id, photo) {
+  for (let attempt = 0;attempt < pageAttemptCount; attempt += 1) {
+    const baseHeaders2 = attempt % 2 === 0 ? navigationHeaders() : firefoxNavigationHeaders();
+    const userAgent2 = baseHeaders2["user-agent"];
+    const headers2 = {
+      ...baseHeaders2,
+      referer: "https://www.tiktok.com/",
+      "sec-fetch-site": "same-origin"
+    };
+    try {
+      return { ...await fetchVideoPage(net, id, headers2), userAgent: userAgent2 };
+    } catch (error) {
+      if (!recoverablePageError(error)) {
+        throw error;
+      }
+    }
+  }
+  if (!photo) {
+    throw new Error("TikTok hydration not found");
+  }
+  const baseHeaders = navigationHeaders();
+  const userAgent = baseHeaders["user-agent"];
+  const headers = {
+    ...baseHeaders,
+    referer: "https://www.tiktok.com/",
+    "sec-fetch-site": "same-origin"
+  };
+  return { ...await fetchEmbedPage(net, id, headers), userAgent };
+}
 function tiktokMetadata(item) {
   const user = object(item.author) ? item.author : null;
   const stats = object(item.stats) ? item.stats : null;
@@ -1460,16 +1739,18 @@ function tiktokMetadata(item) {
     }
   };
 }
-async function fetchVideoPage(net, id, userAgent) {
+async function fetchVideoPage(net, id, headers) {
   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
-    }
+    headers
   });
   return { cookie: cookieHeader(page.headers), item: itemStruct(await page.text()) };
 }
+async function fetchEmbedPage(net, id, headers) {
+  const page = await net(`https://www.tiktok.com/embed/v2/${id}`, {
+    headers
+  });
+  return { cookie: cookieHeader(page.headers), item: embedItemStruct(await page.text(), id) };
+}
 function isShortlinkHost(hostname) {
   return hostname === "vm.tiktok.com" || hostname === "vt.tiktok.com";
 }
@@ -1509,10 +1790,68 @@ function itemStruct(html) {
   }
   return item;
 }
+function embedItemStruct(html, id) {
+  const raw = html.match(/<script\b[^>]*\bid=["']__FRONTITY_CONNECT_STATE__["'][^>]*>([\s\S]*?)<\/script>/i)?.[1];
+  if (!raw) {
+    throw new Error("TikTok embed state not found");
+  }
+  const parsed = JSON.parse(raw);
+  const source2 = object(parsed) && object(parsed.source) ? parsed.source : null;
+  const data = source2 && object(source2.data) ? source2.data : null;
+  const rawRoute = data ? data[`/embed/v2/${id}`] : null;
+  const route = object(rawRoute) ? rawRoute : null;
+  const videoData = route && object(route.videoData) ? route.videoData : null;
+  const item = videoData && object(videoData.itemInfos) ? videoData.itemInfos : null;
+  if (!videoData || !item) {
+    throw new Error("TikTok embed item not found");
+  }
+  const authorInfo = object(videoData.authorInfos) ? videoData.authorInfos : {};
+  const musicInfo = object(videoData.musicInfos) ? videoData.musicInfos : {};
+  const video = object(item.video) ? item.video : {};
+  const videoMeta = object(video.videoMeta) ? video.videoMeta : {};
+  const imagePost = object(videoData.imagePostInfo) ? videoData.imagePostInfo : null;
+  const displayImages = imagePost && Array.isArray(imagePost.displayImages) ? imagePost.displayImages.filter(object) : [];
+  if (displayImages.length === 0) {
+    throw new Error("TikTok video hydration not found");
+  }
+  return {
+    ...item,
+    author: {
+      nickname: string(authorInfo.nickName),
+      uniqueId: string(authorInfo.uniqueId),
+      verified: bool(authorInfo.verified)
+    },
+    desc: string(item.text),
+    imagePost: {
+      images: displayImages.map((image) => ({
+        imageURL: {
+          urlList: Array.isArray(image.urlList) ? image.urlList.map(string).filter((url) => Boolean(url)) : []
+        }
+      }))
+    },
+    music: {
+      authorName: string(musicInfo.authorName),
+      playUrl: firstString(musicInfo.playUrl),
+      title: string(musicInfo.musicName)
+    },
+    stats: {
+      commentCount: item.commentCount,
+      diggCount: item.diggCount,
+      playCount: item.playCount,
+      shareCount: item.shareCount
+    },
+    video: {
+      duration: videoMeta.duration
+    }
+  };
+}
 function recoverablePageError(error) {
   const message = error instanceof Error ? error.message : "";
   return message === "TikTok WAF challenge" || message === "TikTok hydration not found";
 }
+function firstString(value) {
+  return Array.isArray(value) ? value.map(string).find((candidate) => candidate !== null) ?? null : string(value);
+}
 function downloadUrl(item) {
   const video = object(item.video) ? item.video : null;
   return video ? string(video.playAddr) ?? string(video.downloadAddr) : null;
@@ -1538,8 +1877,8 @@ function imageItems3(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 imageUrl2 = object(image.imageURL) ? image.imageURL : null;
+    const list = imageUrl2 && Array.isArray(imageUrl2.urlList) ? imageUrl2.urlList : [];
     const url = list.map(string).find((candidate) => Boolean(candidate)) ?? null;
     return url ? [{
       filename: filename(`tiktok_${user}_${id}_${index + 1}.jpg`),
@@ -1596,8 +1935,10 @@ async function resolveTwitter(input) {
   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));
+  const items = twitterTweets(tweet, id).flatMap(({ id: postId2, tweet: post }) => {
+    const media = Array.isArray(post.mediaDetails) ? post.mediaDetails.filter(object) : [];
+    return media.flatMap((entry, index) => twitterItem(entry, postId2, index + 1));
+  });
   if (items.length === 0) {
     throw new Error("Twitter media not found");
   }
@@ -1605,6 +1946,16 @@ async function resolveTwitter(input) {
 }
 function twitterMetadata(tweet) {
   const user = object(tweet.user) ? tweet.user : null;
+  const extra = {};
+  const lang = string(tweet.lang);
+  if (lang) {
+    extra.lang = lang;
+  }
+  const quotedTweet = object(tweet.quoted_tweet) ? tweet.quoted_tweet : null;
+  const quotedId = quotedTweet ? string(quotedTweet.id_str) : null;
+  if (quotedTweet && quotedId) {
+    extra.quotedTweet = { id: quotedId, metadata: twitterMetadata(quotedTweet) };
+  }
   return {
     text: string(tweet.text) ?? string(tweet.full_text) ?? undefined,
     author: user ? {
@@ -1618,9 +1969,26 @@ function twitterMetadata(tweet) {
     shareCount: count(tweet.retweet_count),
     viewCount: count(tweet.view_count),
     nsfw: bool(tweet.possibly_sensitive),
-    extra: { lang: string(tweet.lang) ?? undefined }
+    extra
   };
 }
+function twitterTweets(tweet, rootId) {
+  const tweets = [];
+  const seen = new Set;
+  let current = tweet;
+  let fallbackId = rootId;
+  while (current) {
+    const id = string(current.id_str) ?? fallbackId;
+    if (!id || seen.has(id)) {
+      break;
+    }
+    tweets.push({ id, tweet: current });
+    seen.add(id);
+    current = object(current.quoted_tweet) ? current.quoted_tweet : null;
+    fallbackId = null;
+  }
+  return tweets;
+}
 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() } });
@@ -1886,16 +2254,25 @@ async function postfetch(url, options = {}) {
   if (trimmed.length === 0) {
     throw new PostfetchError(400, "url is required");
   }
+  if (options.tryMaxBytes !== undefined && (!Number.isSafeInteger(options.tryMaxBytes) || options.tryMaxBytes <= 0)) {
+    throw new PostfetchError(400, "tryMaxBytes must be a positive integer");
+  }
   const context = {
     net: createNet(options.fetch ?? globalThis.fetch),
     preferredWidth: options.preferredWidth ?? 720,
     url: trimmed
   };
-  switch (detect(trimmed)) {
+  const result = await resolve(context);
+  return options.tryMaxBytes === undefined ? result : trySmaller(context, result, options.tryMaxBytes);
+}
+async function resolve(context) {
+  switch (detect(context.url)) {
     case "facebook":
       return resolveFacebook(context);
     case "instagram":
       return resolveInstagram(context);
+    case "linkedin":
+      return resolveLinkedin(context);
     case "pinterest":
       return resolvePinterest(context);
     case "reddit":
@@ -1910,6 +2287,58 @@ async function postfetch(url, options = {}) {
       return resolveYoutube(context);
   }
 }
+async function trySmaller(context, result, maxBytes) {
+  const originalBytes = await resultBytes(context, result);
+  if (originalBytes === null || originalBytes <= maxBytes) {
+    return result;
+  }
+  try {
+    const smaller = await resolve({ ...context, preferredWidth: 1 });
+    if (sameMedia(result, smaller)) {
+      return result;
+    }
+    const smallerBytes = await resultBytes(context, smaller);
+    return smallerBytes !== null && smallerBytes < originalBytes ? smaller : result;
+  } catch {
+    return result;
+  }
+}
+async function resultBytes(context, result) {
+  const sizes = await Promise.all(result.items.map((item) => itemBytes(context, item)));
+  if (sizes.some((size) => size === null)) {
+    return null;
+  }
+  return sizes.reduce((total, size) => total + (size ?? 0), 0);
+}
+async function itemBytes(context, item) {
+  if (item.hls) {
+    return null;
+  }
+  const [video, audio] = await Promise.all([
+    contentLength(context, item.url, item.headers),
+    item.audio ? contentLength(context, item.audio.url, item.audio.headers) : Promise.resolve(0)
+  ]);
+  return video === null || audio === null ? null : video + audio;
+}
+async function contentLength(context, url, headers) {
+  try {
+    const response = await context.net(url, { headers, method: "HEAD" }, 1);
+    const raw = response.ok ? response.headers.get("content-length") : null;
+    if (!raw || !/^\d+$/.test(raw)) {
+      return null;
+    }
+    const bytes = Number(raw);
+    return Number.isSafeInteger(bytes) ? bytes : null;
+  } catch {
+    return null;
+  }
+}
+function sameMedia(left, right) {
+  return left.items.length === right.items.length && left.items.every((item, index) => {
+    const other = right.items[index];
+    return item.url === other?.url && item.audio?.url === other.audio?.url;
+  });
+}
 function detect(url) {
   const host = asUrl(url).hostname;
   if (host.includes("tiktok.com")) {
@@ -1918,6 +2347,9 @@ function detect(url) {
   if (host.includes("instagram.com")) {
     return "instagram";
   }
+  if (host === "linkedin.com" || host.endsWith(".linkedin.com")) {
+    return "linkedin";
+  }
   if (host.includes("pinterest.") || host === "pin.it") {
     return "pinterest";
   }
@@ -1936,7 +2368,7 @@ function detect(url) {
   if (host === "x.com" || host.endsWith(".x.com") || host.includes("twitter.com")) {
     return "twitter";
   }
-  throw new PostfetchError(400, "only Facebook, Instagram, Pinterest, Reddit, SoundCloud, TikTok, X and YouTube URLs are supported");
+  throw new PostfetchError(400, "only Facebook, Instagram, LinkedIn, Pinterest, Reddit, SoundCloud, TikTok, X and YouTube URLs are supported");
 }
 // src/remux.ts
 function mergeAudioVideo(video, audio) {
@@ -2164,7 +2596,7 @@ function buffered(item) {
 async function download(item, options = {}) {
   const net = createNet(options.fetch ?? globalThis.fetch);
   if (buffered(item)) {
-    const bytes = await itemBytes(net, item);
+    const bytes = await itemBytes2(net, item);
     return new Response(toArrayBuffer(bytes), { headers: { "content-length": String(bytes.length), "content-type": item.mime } });
   }
   const response = await net(item.url, { headers: item.headers });
@@ -2173,9 +2605,17 @@ async function download(item, options = {}) {
   }
   return response;
 }
+async function downloadBlob(url, headers = {}, options = {}) {
+  const net = createNet(options.fetch ?? globalThis.fetch);
+  const response = await net(url, { headers });
+  if (!response.ok || !response.body) {
+    throw new PostfetchError(502, `download failed: ${response.status}`);
+  }
+  return response.blob();
+}
 async function archive(result, options = {}) {
   const net = createNet(options.fetch ?? globalThis.fetch);
-  const files = await Promise.all(result.items.map(async (item) => ({ data: await itemBytes(net, item), name: item.filename })));
+  const files = await Promise.all(result.items.map(async (item) => ({ data: await itemBytes2(net, item), name: item.filename })));
   return { bytes: zip(files), filename: result.archiveFilename, mime: "application/zip" };
 }
 async function toResponse(result, options = {}) {
@@ -2187,7 +2627,7 @@ async function toResponse(result, options = {}) {
 async function singleResponse(item, options) {
   if (buffered(item)) {
     const net = createNet(options.fetch ?? globalThis.fetch);
-    const bytes = await itemBytes(net, item);
+    const bytes = await itemBytes2(net, item);
     return new Response(toArrayBuffer(bytes), {
       headers: {
         "content-disposition": `attachment; filename="${item.filename}"`,
@@ -2228,7 +2668,7 @@ async function archiveResponse(result, options) {
     }
   });
 }
-async function itemBytes(net, item) {
+async function itemBytes2(net, item) {
   if (item.hls) {
     const video = await assembleHls(net, item.url, item.headers);
     if (item.audio) {
@@ -2261,6 +2701,7 @@ function toArrayBuffer(bytes) {
 export {
   toResponse,
   postfetch,
+  downloadBlob,
   download,
   detect,
   archive,