@postfetch/core 0.5.1 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # @postfetch/core
 
-Zero-dependency typed core that turns Instagram, TikTok and YouTube post URLs into media files. Part of [postfetch](https://github.com/chelokot/postfetch).
+Zero-dependency typed core that turns Facebook, Instagram, LinkedIn, Pinterest, Reddit, SoundCloud, TikTok, X and YouTube post URLs into media files. Part of [postfetch](https://github.com/chelokot/postfetch).
 
 ```ts
 import { postfetch, download, archive, toResponse, PostfetchError } from "@postfetch/core";

package/dist/fingerprint.d.ts

@@ -4,8 +4,12 @@ export type BrowserFingerprint = {
     secChUaPlatform: string;
     userAgent: string;
 };
+export type NavigationHeaders = Record<string, string> & {
+    "user-agent": string;
+};
 export declare function browserFingerprint(): BrowserFingerprint;
-export declare function navigationHeaders(): Record<string, string>;
+export declare function navigationHeaders(): NavigationHeaders;
 export declare function browserUserAgent(): string;
 export declare function firefoxUserAgent(): string;
+export declare function firefoxNavigationHeaders(userAgent?: string): NavigationHeaders;
 export declare function instagramAppUserAgent(): string;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Turn a public social post URL into its media.
  *
- * {@link postfetch} resolves Instagram, TikTok, YouTube, Facebook and X (Twitter)
+ * {@link postfetch} resolves Instagram, LinkedIn, TikTok, YouTube, Facebook and X (Twitter)
  * URLs to typed {@link MediaItem}s. Zero dependencies, only Web-standard APIs
  * (`fetch`, `Response`, `URL`, `crypto`) — so it runs on Deno, Node, Bun,
  * Cloudflare Workers and browsers alike. It only resolves the media; the

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,6 +153,9 @@ 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);
 }
@@ -156,7 +164,9 @@ function instagramAppUserAgent() {
 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);
+  const embed = await embedVideo(input.net, canonical);
+  const watch = !embed && /^\d+$/.test(id) ? await watchVideo(input.net, id) : null;
+  const url = embed ?? watch?.url ?? null;
   if (!url) {
     throw new Error("Facebook video not found");
   }
@@ -169,7 +179,7 @@ async function resolveFacebook(input) {
     platform: "facebook",
     url
   };
-  return { archiveFilename: filename(`facebook_${id}.zip`), id, items: [item], platform: "facebook" };
+  return { archiveFilename: filename(`facebook_${id}.zip`), id, items: [item], metadata: watch?.metadata, platform: "facebook" };
 }
 function navigationHeaders2() {
   return {
@@ -192,6 +202,25 @@ async function embedVideo(net, canonical) {
   const html = await response.text();
   return source(html, "hd_src") ?? source(html, "sd_src");
 }
+async function watchVideo(net, id) {
+  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");
+  return url ? { url, metadata: watchMetadata(html) } : null;
+}
+function watchMetadata(html) {
+  const owner = html.match(/"name":("(?:\\.|[^"\\])*"),"__isVideoOwner"/);
+  const name = owner ? JSON.parse(owner[1]) : undefined;
+  return {
+    author: name ? { name } : undefined,
+    createdAt: isoFromEpochSeconds(html.match(/"publish_time":(\d+)/)?.[1]),
+    viewCount: count(html.match(/"video_view_count":(\d+)/)?.[1])
+  };
+}
 function source(html, key) {
   const match = html.match(new RegExp(`"${key}":("(?:\\\\.|[^"\\\\])*")`));
   if (!match) {
@@ -250,7 +279,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);
   }
@@ -460,23 +503,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"
@@ -502,14 +542,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) ?? "",
@@ -543,6 +583,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;
 }
@@ -562,6 +608,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}`;
@@ -625,6 +689,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);
@@ -1386,23 +1652,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;
@@ -1413,6 +1674,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;
@@ -1439,16 +1729,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";
 }
@@ -1488,10 +1780,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;
@@ -1517,8 +1867,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`),
@@ -1875,6 +2225,8 @@ async function postfetch(url, options = {}) {
       return resolveFacebook(context);
     case "instagram":
       return resolveInstagram(context);
+    case "linkedin":
+      return resolveLinkedin(context);
     case "pinterest":
       return resolvePinterest(context);
     case "reddit":
@@ -1897,6 +2249,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";
   }
@@ -1915,7 +2270,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) {

package/dist/internal.d.ts

@@ -1,5 +1,5 @@
 /** A platform that {@link postfetch} can resolve. */
-export type Platform = "facebook" | "instagram" | "pinterest" | "reddit" | "soundcloud" | "tiktok" | "twitter" | "youtube";
+export type Platform = "facebook" | "instagram" | "linkedin" | "pinterest" | "reddit" | "soundcloud" | "tiktok" | "twitter" | "youtube";
 /** The kind of a {@link MediaItem}. */
 export type MediaKind = "audio" | "image" | "video";
 /** A single resolved media file: a direct URL plus everything needed to fetch and name it. */
@@ -137,7 +137,7 @@ export type PinterestExtra = {
     outboundLink?: string;
 };
 /** The result of resolving a post: its platform, id, media items and metadata. */
-export type PostfetchResult = PlatformResult<"facebook", never> | PlatformResult<"instagram", InstagramExtra> | PlatformResult<"pinterest", PinterestExtra> | PlatformResult<"reddit", RedditExtra> | PlatformResult<"soundcloud", SoundcloudExtra> | PlatformResult<"tiktok", TiktokExtra> | PlatformResult<"twitter", TwitterExtra> | PlatformResult<"youtube", YoutubeExtra>;
+export type PostfetchResult = PlatformResult<"facebook", never> | PlatformResult<"instagram", InstagramExtra> | PlatformResult<"linkedin", never> | PlatformResult<"pinterest", PinterestExtra> | PlatformResult<"reddit", RedditExtra> | PlatformResult<"soundcloud", SoundcloudExtra> | PlatformResult<"tiktok", TiktokExtra> | PlatformResult<"twitter", TwitterExtra> | PlatformResult<"youtube", YoutubeExtra>;
 /** One platform's variant of a {@link PostfetchResult}, carrying that platform's `extra` metadata shape. */
 export type PlatformResult<P extends Platform, Extra> = {
     /** Suggested filename when zipping every item. */

package/dist/linkedin.d.ts

@@ -0,0 +1,3 @@
+import { type Json, type PostMetadata, type PostfetchResult, type ResolveContext } from "./internal";
+export declare function resolveLinkedin(input: ResolveContext): Promise<PostfetchResult>;
+export declare function linkedinMetadata(post: Json): PostMetadata;

package/dist/postfetch.d.ts

@@ -14,7 +14,7 @@ export type PostfetchOptions = {
  * performs no side effects beyond the lookup; use {@link download}, {@link archive}
  * or {@link toResponse} to turn the result into bytes or a `Response`.
  *
- * @param url A post URL from Instagram, TikTok, YouTube, Facebook or X.
+ * @param url A post URL from a supported platform.
  * @param options See {@link PostfetchOptions}.
  * @returns The resolved post and its media items.
  * @throws {PostfetchError} If the URL is empty or its host is unsupported.