@postfetch/core 0.2.3 → 0.3.0

package/dist/index.js

@@ -520,6 +520,714 @@ function randomToken(length = 8) {
   return crypto.getRandomValues(new Uint8Array(length)).reduce((value, byte) => value + (byte % 36).toString(36), "");
 }
 
+// src/isobmff.ts
+function parseBoxes(data, start = 0, end = data.length) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const boxes = [];
+  let offset = start;
+  while (offset + 8 <= end) {
+    let size = view.getUint32(offset);
+    const type = String.fromCharCode(data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7]);
+    let dataStart = offset + 8;
+    if (size === 1) {
+      size = Number(view.getBigUint64(offset + 8));
+      dataStart = offset + 16;
+    } else if (size === 0) {
+      size = end - offset;
+    }
+    if (size < 8 || offset + size > end) {
+      break;
+    }
+    boxes.push({ type, start: offset, end: offset + size, dataStart });
+    offset += size;
+  }
+  return boxes;
+}
+function findBox(boxes, type) {
+  return boxes.find((box) => box.type === type);
+}
+function childBoxes(data, box) {
+  return parseBoxes(data, box.dataStart, box.end);
+}
+function sliceBox(data, box) {
+  return data.slice(box.start, box.end);
+}
+function buildBox(type, payload) {
+  const out = new Uint8Array(8 + payload.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, out.length);
+  out[4] = type.charCodeAt(0);
+  out[5] = type.charCodeAt(1);
+  out[6] = type.charCodeAt(2);
+  out[7] = type.charCodeAt(3);
+  out.set(payload, 8);
+  return out;
+}
+function concat(parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function readU32(data, offset) {
+  return new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(offset);
+}
+function writeU32(data, offset, value) {
+  new DataView(data.buffer, data.byteOffset, data.byteLength).setUint32(offset, value);
+}
+function boxVersion(data, box) {
+  return data[box.dataStart];
+}
+
+// src/hls.ts
+function isMasterPlaylist(text) {
+  return text.includes("#EXT-X-STREAM-INF");
+}
+function parseMaster(text, baseUrl) {
+  const lines = text.split(`
+`).map((line) => line.trim());
+  const audio = {};
+  const variants = [];
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.startsWith("#EXT-X-MEDIA:") && /TYPE=AUDIO/.test(line)) {
+      const group = line.match(/GROUP-ID="([^"]+)"/)?.[1];
+      const uri = line.match(/URI="([^"]+)"/)?.[1];
+      if (group && uri) {
+        audio[group] = new URL(uri, baseUrl).href;
+      }
+    } else if (line.startsWith("#EXT-X-STREAM-INF:")) {
+      const target = lines[index + 1];
+      if (target && !target.startsWith("#")) {
+        const resolution = line.match(/RESOLUTION=(\d+)x(\d+)/);
+        variants.push({
+          width: resolution ? Number(resolution[1]) : 0,
+          height: resolution ? Number(resolution[2]) : 0,
+          bandwidth: Number(line.match(/BANDWIDTH=(\d+)/)?.[1] ?? 0),
+          url: new URL(target, baseUrl).href,
+          audioGroup: line.match(/AUDIO="([^"]+)"/)?.[1] ?? null
+        });
+      }
+    }
+  }
+  return { variants, audio };
+}
+async function assembleHls(net, playlistUrl, headers) {
+  const response = await net(playlistUrl, { headers });
+  if (!response.ok) {
+    throw new Error(`HLS playlist failed: ${response.status}`);
+  }
+  const segments = mediaSegments(await response.text(), playlistUrl);
+  if (segments.length === 0) {
+    throw new Error("HLS playlist has no segments");
+  }
+  return concat(await fetchSegments(net, segments, headers));
+}
+function mediaSegments(text, baseUrl) {
+  const segments = [];
+  let pendingRange = null;
+  let nextOffset = 0;
+  for (const raw of text.split(`
+`)) {
+    const line = raw.trim();
+    if (line.startsWith("#EXT-X-MAP:")) {
+      const uri = line.match(/URI="([^"]+)"/)?.[1];
+      if (uri) {
+        const range = byteRange(line.match(/BYTERANGE="([^"]+)"/)?.[1], nextOffset);
+        segments.push({ url: new URL(uri, baseUrl).href, range });
+        nextOffset = range ? range.offset + range.length : nextOffset;
+      }
+    } else if (line.startsWith("#EXT-X-BYTERANGE:")) {
+      pendingRange = byteRange(line.slice("#EXT-X-BYTERANGE:".length), nextOffset);
+      nextOffset = pendingRange ? pendingRange.offset + pendingRange.length : nextOffset;
+    } else if (line.length > 0 && !line.startsWith("#")) {
+      segments.push({ url: new URL(line, baseUrl).href, range: pendingRange });
+      pendingRange = null;
+    }
+  }
+  return segments;
+}
+function byteRange(spec, runningOffset) {
+  const match = spec?.trim().match(/^(\d+)(?:@(\d+))?$/);
+  if (!match) {
+    return null;
+  }
+  return { length: Number(match[1]), offset: match[2] === undefined ? runningOffset : Number(match[2]) };
+}
+async function fetchSegments(net, segments, headers) {
+  const results = new Array(segments.length);
+  let cursor = 0;
+  async function worker() {
+    while (cursor < segments.length) {
+      const index = cursor;
+      cursor += 1;
+      results[index] = await fetchSegment(net, segments[index], headers);
+    }
+  }
+  const workers = Array.from({ length: Math.min(8, segments.length) }, worker);
+  await Promise.all(workers);
+  return results;
+}
+async function fetchSegment(net, segment, headers) {
+  const requestHeaders = new Headers(headers);
+  if (segment.range) {
+    requestHeaders.set("range", `bytes=${segment.range.offset}-${segment.range.offset + segment.range.length - 1}`);
+  }
+  const response = await net(segment.url, { headers: requestHeaders });
+  if (!response.ok) {
+    throw new Error(`HLS segment failed: ${response.status}`);
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+
+// src/pinterest.ts
+async function resolvePinterest(input) {
+  const id = await pinId(input.net, input.url);
+  const pin = await pinResource(input.net, id);
+  const items = await mediaItems2(input, pin, id);
+  if (items.length === 0) {
+    throw new Error("Pinterest media not found");
+  }
+  return { archiveFilename: filename(`pinterest_${id}.zip`), id, items, platform: "pinterest" };
+}
+async function pinId(net, input) {
+  const direct = parsePin(input);
+  if (direct) {
+    return direct;
+  }
+  const response = await net(input, { headers: { "user-agent": browserUserAgent() } }, 1);
+  const resolved = parsePin(response.url);
+  if (!resolved) {
+    throw new Error("Pinterest pin id not found");
+  }
+  return resolved;
+}
+function parsePin(input) {
+  return asUrl(input).pathname.match(/\/pin\/(\d+)/)?.[1] ?? null;
+}
+async function pinResource(net, id) {
+  const data = JSON.stringify({
+    options: { id, field_set_key: "unauth_react_main_pin", fetch_visual_search_objects: false },
+    context: {}
+  });
+  const url = new URL("https://www.pinterest.com/resource/PinResource/get/");
+  url.searchParams.set("source_url", `/pin/${id}/`);
+  url.searchParams.set("data", data);
+  const response = await net(url.href, {
+    headers: {
+      accept: "application/json",
+      "user-agent": browserUserAgent(),
+      "x-pinterest-pws-handler": "www/pin/[id].js"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Pinterest resource failed: ${response.status}`);
+  }
+  const payload = await response.json().catch(() => null);
+  const wrapper = object(payload) && object(payload.resource_response) ? payload.resource_response : null;
+  const pin = wrapper && object(wrapper.data) ? wrapper.data : null;
+  if (!pin) {
+    throw new Error("Pinterest pin not found");
+  }
+  return pin;
+}
+async function mediaItems2(input, pin, id) {
+  const video = await standardVideo(input, pin, id);
+  if (video.length > 0) {
+    return video;
+  }
+  const story = await storyItems(input, pin, id);
+  if (story.length > 0) {
+    return story;
+  }
+  return imageItems(pin, id);
+}
+async function standardVideo(input, pin, id) {
+  const item = await videoFromList(input, id, null, videoList(object(pin.videos) ? pin.videos : null));
+  return item ? [item] : [];
+}
+async function storyItems(input, pin, id) {
+  const story = object(pin.story_pin_data) ? pin.story_pin_data : null;
+  if (!story) {
+    return [];
+  }
+  const pages = Array.isArray(story.pages) ? story.pages.filter(object) : [];
+  const blocks = pages.flatMap((page) => Array.isArray(page.blocks) ? page.blocks.filter(object) : []);
+  const videoBlocks = blocks.filter((block) => object(block.video));
+  const videos = [];
+  for (const [index, block] of videoBlocks.entries()) {
+    const item = await videoFromList(input, id, index + 1, videoList(object(block.video) ? block.video : null));
+    if (item) {
+      videos.push(item);
+    }
+  }
+  if (videos.length > 0) {
+    return videos;
+  }
+  if (videoBlocks.length > 0) {
+    throw new Error("Pinterest idea pin video has no downloadable rendition");
+  }
+  return imageItems(pin, id);
+}
+async function videoFromList(input, id, index, renditions) {
+  const progressive = progressiveMp4(renditions);
+  if (progressive) {
+    return videoItem(id, index, progressive);
+  }
+  const master = hlsUrl(renditions);
+  return master ? hlsVideoItem(input.net, id, index, master, input.preferredWidth) : null;
+}
+async function hlsVideoItem(net, id, index, masterUrl, preferredWidth) {
+  const headers = { "user-agent": browserUserAgent() };
+  const suffix = index === null ? "" : `_${index}`;
+  const base = {
+    filename: filename(`pinterest_${id}${suffix}.mp4`),
+    headers,
+    hls: true,
+    id,
+    kind: "video",
+    mime: "video/mp4",
+    platform: "pinterest",
+    url: masterUrl
+  };
+  const response = await net(masterUrl, { headers });
+  if (!response.ok) {
+    throw new Error(`Pinterest HLS failed: ${response.status}`);
+  }
+  const playlist = await response.text();
+  if (!isMasterPlaylist(playlist)) {
+    return base;
+  }
+  const master = parseMaster(playlist, masterUrl);
+  const variant = pickVariant(master.variants, preferredWidth);
+  if (!variant) {
+    throw new Error("Pinterest HLS variant not found");
+  }
+  const audioUrl = variant.audioGroup ? master.audio[variant.audioGroup] : undefined;
+  return { ...base, url: variant.url, ...audioUrl ? { audio: { headers, url: audioUrl } } : {} };
+}
+function pickVariant(variants, preferredWidth) {
+  return variants.reduce((current, variant) => {
+    if (!current) {
+      return variant;
+    }
+    return Math.abs(variant.width - preferredWidth) < Math.abs(current.width - preferredWidth) ? variant : current;
+  }, null);
+}
+function hlsUrl(renditions) {
+  return renditions.map((rendition) => string(rendition.url)).find((url) => url !== null && url.toLowerCase().includes(".m3u8")) ?? null;
+}
+function imageItems(pin, id) {
+  const images = object(pin.images) ? pin.images : null;
+  const orig = images && object(images.orig) ? images.orig : null;
+  const url = orig ? string(orig.url) : null;
+  if (!url) {
+    return [];
+  }
+  return [
+    {
+      filename: filename(`pinterest_${id}.${imageExtension(url)}`),
+      headers: { "user-agent": browserUserAgent() },
+      id,
+      kind: "image",
+      mime: imageMime(url),
+      platform: "pinterest",
+      url
+    }
+  ];
+}
+function videoList(videos) {
+  const list = videos && object(videos.video_list) ? videos.video_list : null;
+  return list ? Object.values(list).filter(object) : [];
+}
+function progressiveMp4(renditions) {
+  const mp4s = renditions.filter((rendition) => string(rendition.url)?.toLowerCase().endsWith(".mp4"));
+  const best = mp4s.reduce((current, rendition) => {
+    const width = number(rendition.width) ?? 0;
+    const currentWidth = current ? number(current.width) ?? 0 : -1;
+    return width > currentWidth ? rendition : current;
+  }, null);
+  return best ? string(best.url) : null;
+}
+function videoItem(id, index, url) {
+  const suffix = index === null ? "" : `_${index}`;
+  return {
+    filename: filename(`pinterest_${id}${suffix}.mp4`),
+    headers: { "user-agent": browserUserAgent() },
+    id,
+    kind: "video",
+    mime: "video/mp4",
+    platform: "pinterest",
+    url
+  };
+}
+function imageExtension(url) {
+  const extension = asUrl(url).pathname.match(/\.([a-z0-9]+)$/i)?.[1]?.toLowerCase();
+  return extension === "png" || extension === "webp" || extension === "gif" ? extension : "jpg";
+}
+function imageMime(url) {
+  const extension = imageExtension(url);
+  if (extension === "png") {
+    return "image/png";
+  }
+  if (extension === "webp") {
+    return "image/webp";
+  }
+  if (extension === "gif") {
+    return "image/gif";
+  }
+  return "image/jpeg";
+}
+
+// src/reddit.ts
+var installedClientId = "ohXpoqrZYub1kg";
+async function resolveReddit(input) {
+  const id = await postId(input.net, input.url);
+  const token = await appToken(input.net);
+  const post = await fetchPost(input.net, token, id);
+  const items = await mediaItems3(input, post, id);
+  if (items.length === 0) {
+    throw new Error("Reddit media not found");
+  }
+  return { archiveFilename: filename(`reddit_${id}.zip`), id, items, platform: "reddit" };
+}
+async function postId(net, input) {
+  const direct = parseId(input);
+  if (direct) {
+    return direct;
+  }
+  const response = await net(input, { headers: { "user-agent": browserUserAgent() } }, 1);
+  const resolved = parseId(response.url);
+  if (!resolved) {
+    throw new Error("Reddit post id not found");
+  }
+  return resolved;
+}
+function parseId(input) {
+  const url = asUrl(input);
+  if (url.hostname === "redd.it") {
+    const slug = url.pathname.split("/").filter(Boolean)[0];
+    return slug && /^[a-z0-9]+$/i.test(slug) ? slug : null;
+  }
+  return url.pathname.match(/\/comments\/([a-z0-9]+)/i)?.[1] ?? null;
+}
+async function appToken(net) {
+  const response = await net("https://www.reddit.com/api/v1/access_token", {
+    body: "grant_type=https://oauth.reddit.com/grants/installed_client&device_id=DO_NOT_TRACK_THIS_DEVICE",
+    headers: {
+      authorization: `Basic ${btoa(`${installedClientId}:`)}`,
+      "content-type": "application/x-www-form-urlencoded",
+      "user-agent": browserUserAgent()
+    },
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error(`Reddit auth failed: ${response.status}`);
+  }
+  const payload = await response.json().catch(() => null);
+  const token = object(payload) ? string(payload.access_token) : null;
+  if (!token) {
+    throw new Error("Reddit token not found");
+  }
+  return token;
+}
+async function fetchPost(net, token, id) {
+  const response = await net(`https://oauth.reddit.com/comments/${id}?raw_json=1&limit=1`, {
+    headers: { authorization: `Bearer ${token}`, "user-agent": browserUserAgent() }
+  });
+  if (!response.ok) {
+    throw new Error(`Reddit post failed: ${response.status}`);
+  }
+  const payload = await response.json().catch(() => null);
+  const listing = Array.isArray(payload) ? payload[0] : null;
+  const children = object(listing) && object(listing.data) && Array.isArray(listing.data.children) ? listing.data.children : [];
+  const first = children[0];
+  const post = object(first) && object(first.data) ? first.data : null;
+  if (!post) {
+    throw new Error("Reddit post not found");
+  }
+  return post;
+}
+async function mediaItems3(input, post, id) {
+  const own = await extract(input, post, id);
+  if (own.length > 0) {
+    return own;
+  }
+  const parents = Array.isArray(post.crosspost_parent_list) ? post.crosspost_parent_list.filter(object) : [];
+  return parents[0] ? extract(input, parents[0], id) : [];
+}
+async function extract(input, post, id) {
+  const gallery = galleryItems(post, id);
+  if (gallery.length > 0) {
+    return gallery;
+  }
+  const video = await videoItems(input, post, id);
+  if (video.length > 0) {
+    return video;
+  }
+  return imageItems2(post, id);
+}
+function galleryItems(post, id) {
+  const data = object(post.gallery_data) ? post.gallery_data : null;
+  const order = data && Array.isArray(data.items) ? data.items.filter(object) : [];
+  const metadata = object(post.media_metadata) ? post.media_metadata : {};
+  return order.flatMap((entry, index) => {
+    const mediaId2 = string(entry.media_id);
+    const meta = mediaId2 && object(metadata[mediaId2]) ? metadata[mediaId2] : null;
+    const best = meta && object(meta.s) ? meta.s : null;
+    if (!best) {
+      return [];
+    }
+    const video = string(best.mp4);
+    if (video) {
+      return [mediaItem(id, index + 1, "video", "video/mp4", video)];
+    }
+    const image = string(best.u) ?? string(best.gif);
+    return image ? [mediaItem(id, index + 1, "image", mimeOf(string(meta?.m), image), image)] : [];
+  });
+}
+async function videoItems(input, post, id) {
+  const media = redditVideo(post);
+  const fallback = media ? string(media.fallback_url) : null;
+  if (!media || !fallback) {
+    return [];
+  }
+  if (media.has_audio !== true) {
+    return [mediaItem(id, null, "video", "video/mp4", fallback)];
+  }
+  const dashUrl = string(media.dash_url);
+  const streams = dashUrl ? await dashStreams(input.net, dashUrl, input.preferredWidth) : null;
+  if (!streams) {
+    throw new Error("Reddit DASH manifest unavailable for muxing");
+  }
+  return [muxedVideoItem(id, streams.video, streams.audio)];
+}
+async function dashStreams(net, dashUrl, preferredWidth) {
+  const response = await net(dashUrl, { headers: { "user-agent": browserUserAgent() } });
+  if (!response.ok) {
+    return null;
+  }
+  const manifest = await response.text();
+  const base = dashUrl.slice(0, dashUrl.lastIndexOf("/") + 1);
+  const query = dashUrl.includes("?") ? dashUrl.slice(dashUrl.indexOf("?")) : "";
+  const video = videoRendition(manifest, preferredWidth);
+  const audio = audioRendition(manifest);
+  if (!video || !audio) {
+    return null;
+  }
+  return { video: `${base}${video}${query}`, audio: `${base}${audio}${query}` };
+}
+function videoRendition(manifest, preferredWidth) {
+  const renditions = renditionsOf(manifest, false);
+  const sized = renditions.filter((rendition) => rendition.width !== null);
+  const pool = sized.length > 0 ? sized : renditions;
+  const best = pool.reduce((current, rendition) => {
+    if (!current) {
+      return rendition;
+    }
+    if (rendition.width !== null && current.width !== null) {
+      return Math.abs(rendition.width - preferredWidth) < Math.abs(current.width - preferredWidth) ? rendition : current;
+    }
+    return rendition.bandwidth > current.bandwidth ? rendition : current;
+  }, null);
+  return best ? best.base : null;
+}
+function audioRendition(manifest) {
+  const best = renditionsOf(manifest, true).reduce((current, rendition) => !current || rendition.bandwidth > current.bandwidth ? rendition : current, null);
+  return best ? best.base : null;
+}
+function renditionsOf(manifest, audio) {
+  return manifest.split("<AdaptationSet").slice(1).filter((chunk) => isAudioSet(chunk) === audio).flatMap((chunk) => [...chunk.matchAll(/<Representation\b([^>]*)>([\s\S]*?)<\/Representation>/g)].flatMap((match) => {
+    const segment = match[2].match(/<BaseURL>([^<]+)<\/BaseURL>/)?.[1];
+    if (!segment) {
+      return [];
+    }
+    const width = match[1].match(/(?:^|[^a-zA-Z])width="(\d+)"/)?.[1];
+    return [{ width: width ? Number(width) : null, bandwidth: Number(match[1].match(/bandwidth="(\d+)"/)?.[1] ?? 0), base: segment }];
+  }));
+}
+function isAudioSet(chunk) {
+  const head = chunk.slice(0, chunk.indexOf(">"));
+  return /contentType="audio"/.test(head) || /mimeType="audio/.test(head);
+}
+function muxedVideoItem(id, videoUrl, audioUrl) {
+  return {
+    audio: { headers: { "user-agent": browserUserAgent() }, url: audioUrl },
+    filename: filename(`reddit_${id}.mp4`),
+    headers: { "user-agent": browserUserAgent() },
+    id,
+    kind: "video",
+    mime: "video/mp4",
+    platform: "reddit",
+    url: videoUrl
+  };
+}
+function redditVideo(post) {
+  const secure = object(post.secure_media) ? post.secure_media : null;
+  const media = object(post.media) ? post.media : null;
+  const fromSecure = secure && object(secure.reddit_video) ? secure.reddit_video : null;
+  const fromMedia = media && object(media.reddit_video) ? media.reddit_video : null;
+  return fromSecure ?? fromMedia;
+}
+function imageItems2(post, id) {
+  const url = string(post.url_overridden_by_dest) ?? string(post.url);
+  if (!url) {
+    return [];
+  }
+  const path = asUrl(url).pathname;
+  const isImage = string(post.post_hint) === "image" || asUrl(url).hostname === "i.redd.it" || /\.(jpe?g|png|webp|gif)$/i.test(path);
+  return isImage ? [mediaItem(id, null, "image", mimeOf(null, url), url)] : [];
+}
+function mediaItem(id, index, kind, mime, url) {
+  const suffix = index === null ? "" : `_${index}`;
+  return {
+    filename: filename(`reddit_${id}${suffix}.${extensionOf(mime)}`),
+    headers: { "user-agent": browserUserAgent() },
+    id,
+    kind,
+    mime,
+    platform: "reddit",
+    url
+  };
+}
+function mimeOf(declared, url) {
+  if (declared && declared.includes("/")) {
+    return declared.replace("image/jpg", "image/jpeg");
+  }
+  const extension = asUrl(url).pathname.match(/\.([a-z0-9]+)$/i)?.[1]?.toLowerCase();
+  if (extension === "png") {
+    return "image/png";
+  }
+  if (extension === "webp") {
+    return "image/webp";
+  }
+  if (extension === "gif") {
+    return "image/gif";
+  }
+  return "image/jpeg";
+}
+function extensionOf(mime) {
+  if (mime === "video/mp4") {
+    return "mp4";
+  }
+  if (mime === "image/png") {
+    return "png";
+  }
+  if (mime === "image/webp") {
+    return "webp";
+  }
+  if (mime === "image/gif") {
+    return "gif";
+  }
+  return "jpg";
+}
+
+// src/soundcloud.ts
+async function resolveSoundcloud(input) {
+  const url = await canonicalUrl2(input.net, input.url);
+  const clientId = await appClientId(input.net);
+  const track = await resolveTrack(input.net, url, clientId);
+  const id = trackId(track);
+  const item = await audioItem(input.net, track, id, clientId);
+  return { archiveFilename: filename(`soundcloud_${id}.zip`), id, items: [item], platform: "soundcloud" };
+}
+async function canonicalUrl2(net, input) {
+  const host = asUrl(input).hostname;
+  if (host !== "on.soundcloud.com" && host !== "snd.sc") {
+    return input;
+  }
+  const response = await net(input, { headers: { "user-agent": browserUserAgent() } }, 1);
+  return response.url;
+}
+async function appClientId(net) {
+  const home = await net("https://soundcloud.com/", { headers: { "user-agent": browserUserAgent() } });
+  if (!home.ok) {
+    throw new Error(`SoundCloud home failed: ${home.status}`);
+  }
+  const html = await home.text();
+  const scripts = [...html.matchAll(/<script[^>]+src="(https:\/\/a-v2\.sndcdn\.com\/assets\/[^"]+\.js)"/g)].map((match) => match[1]);
+  for (const src of scripts.reverse()) {
+    const response = await net(src, { headers: { "user-agent": browserUserAgent() } }, 1);
+    if (!response.ok) {
+      continue;
+    }
+    const code = await response.text();
+    const id = code.match(/client_id\s*[:=]\s*"([A-Za-z0-9]{20,})"/)?.[1];
+    if (id) {
+      return id;
+    }
+  }
+  throw new Error("SoundCloud client id not found");
+}
+async function resolveTrack(net, url, clientId) {
+  const api = new URL("https://api-v2.soundcloud.com/resolve");
+  api.searchParams.set("url", url);
+  api.searchParams.set("client_id", clientId);
+  const response = await net(api.href, { headers: { accept: "application/json", "user-agent": browserUserAgent() } });
+  if (!response.ok) {
+    throw new Error(`SoundCloud resolve failed: ${response.status}`);
+  }
+  const payload = await response.json().catch(() => null);
+  if (!object(payload) || string(payload.kind) !== "track") {
+    throw new Error("SoundCloud track not found");
+  }
+  return payload;
+}
+async function audioItem(net, track, id, clientId) {
+  const media = object(track.media) ? track.media : null;
+  const transcodings = media && Array.isArray(media.transcodings) ? media.transcodings.filter(object) : [];
+  const progressive = transcodings.find((transcoding) => protocol(transcoding) === "progressive");
+  const hls = transcodings.find((transcoding) => protocol(transcoding) === "hls" && mimeType(transcoding)?.includes("mp4") === true);
+  const chosen = progressive ?? hls;
+  if (!chosen) {
+    throw new Error("SoundCloud track has no downloadable stream");
+  }
+  const stream = await streamUrl(net, chosen, clientId);
+  const title = string(track.title) ?? id;
+  const headers = { "user-agent": browserUserAgent() };
+  if (chosen === progressive) {
+    return { filename: filename(`soundcloud_${title}.mp3`), headers, id, kind: "audio", mime: "audio/mpeg", platform: "soundcloud", url: stream };
+  }
+  return { filename: filename(`soundcloud_${title}.m4a`), headers, hls: true, id, kind: "audio", mime: "audio/mp4", platform: "soundcloud", url: stream };
+}
+async function streamUrl(net, transcoding, clientId) {
+  const endpoint = string(transcoding.url);
+  if (!endpoint) {
+    throw new Error("SoundCloud stream endpoint not found");
+  }
+  const url = new URL(endpoint);
+  url.searchParams.set("client_id", clientId);
+  const response = await net(url.href, { headers: { accept: "application/json", "user-agent": browserUserAgent() } });
+  if (!response.ok) {
+    throw new Error(`SoundCloud stream failed: ${response.status}`);
+  }
+  const payload = await response.json().catch(() => null);
+  const stream = object(payload) ? string(payload.url) : null;
+  if (!stream) {
+    throw new Error("SoundCloud stream url not found");
+  }
+  return stream;
+}
+function protocol(transcoding) {
+  const format = object(transcoding.format) ? transcoding.format : null;
+  return format ? string(format.protocol) : null;
+}
+function mimeType(transcoding) {
+  const format = object(transcoding.format) ? transcoding.format : null;
+  return format ? string(format.mime_type) : null;
+}
+function trackId(track) {
+  const numeric = number(track.id);
+  if (numeric !== null) {
+    return String(numeric);
+  }
+  return string(track.permalink) ?? "track";
+}
+
 // src/tiktok.ts
 var marker = '<script id="__UNIVERSAL_DATA_FOR_REHYDRATION__" type="application/json">';
 async function resolveTiktok(input) {
@@ -543,7 +1251,7 @@ async function resolveTiktok(input) {
   if (page.cookie) {
     headers.cookie = page.cookie;
   }
-  const items = mediaItems2(page.item, user, id, headers);
+  const items = mediaItems4(page.item, user, id, headers);
   if (items.length === 0) {
     throw new Error("TikTok media not found");
   }
@@ -603,10 +1311,10 @@ 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);
+function mediaItems4(item, user, id, headers) {
+  const images = imageItems3(item, user, id, headers);
   if (images.length > 0) {
-    const audio = audioItem(item, user, id, headers);
+    const audio = audioItem2(item, user, id, headers);
     return audio ? [...images, audio] : images;
   }
   const url = downloadUrl(item);
@@ -620,7 +1328,7 @@ function mediaItems2(item, user, id, headers) {
     url
   }] : [];
 }
-function imageItems(item, user, id, headers) {
+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) => {
@@ -638,7 +1346,7 @@ function imageItems(item, user, id, headers) {
     }] : [];
   });
 }
-function audioItem(item, user, id, headers) {
+function audioItem2(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;
@@ -756,22 +1464,64 @@ async function resolveYoutube(input) {
     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 streams = selectStreams(payload, input.preferredWidth);
+  if (!streams) {
+    throw new Error("YouTube mp4 stream not found");
   }
   const title = object(payload) && object(payload.videoDetails) ? string(payload.videoDetails.title) : null;
+  const headers = { "user-agent": androidVrClient.userAgent };
   const media = {
     filename: filename(`youtube_${title ?? id}_${id}.mp4`),
-    headers: { "user-agent": androidVrClient.userAgent },
+    headers,
     id,
     kind: "video",
     mime: "video/mp4",
     platform: "youtube",
-    url: format
+    url: streams.video,
+    ...streams.audio ? { audio: { headers, url: streams.audio } } : {}
   };
   return { archiveFilename: filename(`youtube_${id}.zip`), id, items: [media], platform: "youtube" };
 }
+function selectStreams(payload, preferredWidth) {
+  const adaptive = adaptiveFormats(payload);
+  const video = bestVideo(adaptive, preferredWidth);
+  const audio = bestAudio(adaptive);
+  if (video && audio) {
+    return { video, audio };
+  }
+  const progressive = selectFormat(payload);
+  return progressive ? { video: progressive, audio: null } : null;
+}
+function adaptiveFormats(payload) {
+  const root = object(payload) ? payload : null;
+  const streaming = root && object(root.streamingData) ? root.streamingData : null;
+  return streaming && Array.isArray(streaming.adaptiveFormats) ? streaming.adaptiveFormats.filter(object) : [];
+}
+function bestVideo(formats, preferredWidth) {
+  const candidates = formats.filter((format) => {
+    const mimeType2 = string(format.mimeType);
+    return Boolean(string(format.url)) && mimeType2?.startsWith("video/mp4") === true && mimeType2.includes("avc1");
+  });
+  const best = candidates.reduce((current, format) => {
+    if (!current) {
+      return format;
+    }
+    const width = number(format.width) ?? 0;
+    const currentWidth = number(current.width) ?? 0;
+    return Math.abs(width - preferredWidth) < Math.abs(currentWidth - preferredWidth) ? format : current;
+  }, null);
+  return best ? string(best.url) : null;
+}
+function bestAudio(formats) {
+  const candidates = formats.filter((format) => Boolean(string(format.url)) && string(format.mimeType)?.startsWith("audio/mp4") === true);
+  const best = candidates.reduce((current, format) => {
+    if (!current) {
+      return format;
+    }
+    return (number(format.bitrate) ?? 0) > (number(current.bitrate) ?? 0) ? format : current;
+  }, null);
+  return best ? string(best.url) : null;
+}
 function playerBody(id, session) {
   return {
     contentCheckOk: true,
@@ -904,6 +1654,12 @@ async function postfetch(url, options = {}) {
       return resolveFacebook(context);
     case "instagram":
       return resolveInstagram(context);
+    case "pinterest":
+      return resolvePinterest(context);
+    case "reddit":
+      return resolveReddit(context);
+    case "soundcloud":
+      return resolveSoundcloud(context);
     case "tiktok":
       return resolveTiktok(context);
     case "twitter":
@@ -920,6 +1676,15 @@ function detect(url) {
   if (host.includes("instagram.com")) {
     return "instagram";
   }
+  if (host.includes("pinterest.") || host === "pin.it") {
+    return "pinterest";
+  }
+  if (host === "reddit.com" || host.endsWith(".reddit.com") || host === "redd.it") {
+    return "reddit";
+  }
+  if (host.includes("soundcloud.com") || host === "snd.sc") {
+    return "soundcloud";
+  }
   if (host.includes("youtube.com") || host === "youtu.be") {
     return "youtube";
   }
@@ -929,8 +1694,135 @@ function detect(url) {
   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");
+  throw new PostfetchError(400, "only Facebook, Instagram, Pinterest, Reddit, SoundCloud, TikTok, X and YouTube URLs are supported");
+}
+// src/remux.ts
+function mergeAudioVideo(video, audio) {
+  const videoSource = analyze(video);
+  const audioSource = analyze(audio);
+  const audioTrackId = videoSource.trackId === 1 ? 2 : 1;
+  const moov = buildMoov(videoSource, audioSource, audioTrackId);
+  const parts = [sliceBox(video, videoSource.ftyp), moov];
+  let sequence = 1;
+  const fragmentCount = Math.max(videoSource.fragments.length, audioSource.fragments.length);
+  for (let index = 0;index < fragmentCount; index += 1) {
+    const videoFragment = videoSource.fragments[index];
+    if (videoFragment) {
+      parts.push(rewriteMoof(video, videoFragment.moof, null, sequence));
+      parts.push(video.subarray(videoFragment.mdat.start, videoFragment.mdat.end));
+      sequence += 1;
+    }
+    const audioFragment = audioSource.fragments[index];
+    if (audioFragment) {
+      parts.push(rewriteMoof(audio, audioFragment.moof, audioTrackId, sequence));
+      parts.push(audio.subarray(audioFragment.mdat.start, audioFragment.mdat.end));
+      sequence += 1;
+    }
+  }
+  return concat(parts);
+}
+function analyze(data) {
+  const top = parseBoxes(data);
+  const ftyp = findBox(top, "ftyp");
+  const moov = findBox(top, "moov");
+  if (!ftyp || !moov) {
+    throw new Error("not a fragmented MP4");
+  }
+  const moovChildren = childBoxes(data, moov);
+  const trak = findBox(moovChildren, "trak");
+  const mvex = findBox(moovChildren, "mvex");
+  if (!trak || !mvex) {
+    throw new Error("MP4 is not fragmented (no trak/mvex)");
+  }
+  const tkhd = findBox(childBoxes(data, trak), "tkhd");
+  if (!tkhd) {
+    throw new Error("track header not found");
+  }
+  const fragments = [];
+  for (let index = 0;index < top.length; index += 1) {
+    if (top[index].type === "moof") {
+      const mdat = top[index + 1];
+      if (!mdat || mdat.type !== "mdat") {
+        throw new Error("fragment without mdat");
+      }
+      fragments.push({ moof: top[index], mdat });
+    }
+  }
+  if (fragments.length === 0) {
+    throw new Error("MP4 has no fragments");
+  }
+  return { data, ftyp, moov, trak, mvex, trackId: trackHeaderId(data, tkhd), fragments };
+}
+function trackHeaderId(data, tkhd) {
+  return readU32(data, tkhd.dataStart + (boxVersion(data, tkhd) === 1 ? 20 : 12));
+}
+function buildMoov(video, audio, audioTrackId) {
+  const moovChildren = childBoxes(video.data, video.moov);
+  const mvhd = patchedMvhd(video, audioTrackId);
+  const meta = findBox(moovChildren, "meta");
+  const videoTrak = sliceBox(video.data, video.trak);
+  const audioTrak = retrackTrak(sliceBox(audio.data, audio.trak), audioTrackId);
+  const mvex = buildMvex(video, audio, audioTrackId);
+  const children = [mvhd];
+  if (meta) {
+    children.push(sliceBox(video.data, meta));
+  }
+  children.push(videoTrak, audioTrak, mvex);
+  return buildBox("moov", concat(children));
+}
+function patchedMvhd(video, audioTrackId) {
+  const mvhd = findBox(childBoxes(video.data, video.moov), "mvhd");
+  if (!mvhd) {
+    throw new Error("movie header not found");
+  }
+  const copy = sliceBox(video.data, mvhd);
+  writeU32(copy, copy.length - 4, Math.max(video.trackId, audioTrackId) + 1);
+  return copy;
+}
+function buildMvex(video, audio, audioTrackId) {
+  const videoMvex = childBoxes(video.data, video.mvex);
+  const mehd = findBox(videoMvex, "mehd");
+  const videoTrex = findBox(videoMvex, "trex");
+  const audioTrex = findBox(childBoxes(audio.data, audio.mvex), "trex");
+  if (!videoTrex || !audioTrex) {
+    throw new Error("track extends box not found");
+  }
+  const audioTrexCopy = sliceBox(audio.data, audioTrex);
+  writeU32(audioTrexCopy, audioTrex.dataStart - audioTrex.start + 4, audioTrackId);
+  const children = [];
+  if (mehd) {
+    children.push(sliceBox(video.data, mehd));
+  }
+  children.push(sliceBox(video.data, videoTrex), audioTrexCopy);
+  return buildBox("mvex", concat(children));
+}
+function retrackTrak(trak, trackId2) {
+  const tkhd = findBox(parseBoxes(trak, 8, trak.length), "tkhd");
+  if (!tkhd) {
+    throw new Error("track header not found");
+  }
+  writeU32(trak, tkhd.dataStart + (boxVersion(trak, tkhd) === 1 ? 20 : 12), trackId2);
+  return trak;
+}
+function rewriteMoof(data, moofBox, trackId2, sequence) {
+  const moof = sliceBox(data, moofBox);
+  const moofChildren = parseBoxes(moof, 8, moof.length);
+  const mfhd = findBox(moofChildren, "mfhd");
+  if (!mfhd) {
+    throw new Error("movie fragment header not found");
+  }
+  writeU32(moof, mfhd.dataStart + 4, sequence);
+  if (trackId2 !== null) {
+    const traf = findBox(moofChildren, "traf");
+    const tfhd = traf ? findBox(parseBoxes(moof, traf.dataStart, traf.end), "tfhd") : undefined;
+    if (!tfhd) {
+      throw new Error("track fragment header not found");
+    }
+    writeU32(moof, tfhd.dataStart + 4, trackId2);
+  }
+  return moof;
 }
+
 // src/zip.ts
 var encoder = new TextEncoder;
 var table = new Uint32Array(256);
@@ -1024,8 +1916,15 @@ function crc32(data) {
 }
 
 // src/download.ts
+function buffered(item) {
+  return Boolean(item.audio) || item.hls === true;
+}
 async function download(item, options = {}) {
   const net = createNet(options.fetch ?? globalThis.fetch);
+  if (buffered(item)) {
+    const bytes = await itemBytes(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 });
   if (!response.ok || !response.body) {
     throw new PostfetchError(502, `download failed: ${response.status}`);
@@ -1034,13 +1933,7 @@ async function download(item, options = {}) {
 }
 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 };
-  }));
+  const files = await Promise.all(result.items.map(async (item) => ({ data: await itemBytes(net, item), name: item.filename })));
   return { bytes: zip(files), filename: result.archiveFilename, mime: "application/zip" };
 }
 async function toResponse(result, options = {}) {
@@ -1050,6 +1943,21 @@ async function toResponse(result, options = {}) {
   return archiveResponse(result, options);
 }
 async function singleResponse(item, options) {
+  if (buffered(item)) {
+    const net = createNet(options.fetch ?? globalThis.fetch);
+    const bytes = await itemBytes(net, item);
+    return new Response(toArrayBuffer(bytes), {
+      headers: {
+        "content-disposition": `attachment; filename="${item.filename}"`,
+        "content-length": String(bytes.length),
+        "content-type": item.mime,
+        "x-media-count": "1",
+        "x-media-id": item.id,
+        "x-media-kind": item.kind,
+        "x-media-platform": item.platform
+      }
+    });
+  }
   const media = await download(item, options);
   const headers = new Headers({
     "content-disposition": `attachment; filename="${item.filename}"`,
@@ -1067,8 +1975,7 @@ async function singleResponse(item, options) {
 }
 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, {
+  return new Response(toArrayBuffer(bytes), {
     headers: {
       "content-disposition": `attachment; filename="${filename2}"`,
       "content-length": String(bytes.length),
@@ -1079,6 +1986,36 @@ async function archiveResponse(result, options) {
     }
   });
 }
+async function itemBytes(net, item) {
+  if (item.hls) {
+    const video = await assembleHls(net, item.url, item.headers);
+    if (item.audio) {
+      return mergeAudioVideo(video, await assembleHls(net, item.audio.url, item.audio.headers));
+    }
+    return video;
+  }
+  if (item.audio) {
+    return mergedBytes(net, item, item.audio);
+  }
+  return fetchBytes(net, item.url, item.headers);
+}
+async function mergedBytes(net, item, audio) {
+  const [video, audioBytes] = await Promise.all([
+    fetchBytes(net, item.url, item.headers),
+    fetchBytes(net, audio.url, audio.headers)
+  ]);
+  return mergeAudioVideo(video, audioBytes);
+}
+async function fetchBytes(net, url, headers) {
+  const response = await net(url, { headers });
+  if (!response.ok) {
+    throw new PostfetchError(502, `download failed: ${response.status}`);
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
 export {
   toResponse,
   postfetch,