@peristyle/emdash-plugin-instagram-to-recipe 0.1.0

package/src/instagram-recipes.ts

@@ -0,0 +1,257 @@
+export type InstagramPostForRecipes = {
+  shortcode: string;
+  caption: string;
+  displayUrl?: string;
+  accessibilityCaption?: string;
+  likes: number;
+  isVideo: boolean;
+  postUrl: string;
+};
+
+export type ParsedInstagramRecipe = {
+  source: {
+    instagram_url: string;
+    shortcode: string;
+    likes: number;
+    is_video: boolean;
+  };
+  suggested_slug: string;
+  title: string;
+  excerpt: string;
+  caption_raw: string;
+  ingredients: string[];
+  instructions: string[];
+  featured_image?: {
+    url: string;
+    alt: string;
+    filename: string;
+    /** Populated when the image is uploaded to EmDash media during convert. */
+    emdash_media?: {
+      provider: string;
+      id: string;
+      src: string;
+      mimeType?: string;
+      meta?: { storageKey: string };
+    };
+    /** True when convert could not upload the image to media library. */
+    upload_failed?: boolean;
+  };
+  /** Set when convert succeeds but no featured image could be resolved. */
+  image_notice?: string;
+};
+
+export function titleCase(s: string): string {
+  return s
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join(" ");
+}
+
+export function slugifyRecipeTitle(title: string): string {
+  const s = title
+    .toLowerCase()
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return s.slice(0, 80) || "instagram-recipe";
+}
+
+function stripHashtagsAndMentions(text: string): string {
+  return text
+    .replace(/@[\w.]+/g, "")
+    .replace(/#\w+/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function isLikelyNonRecipeCaption(caption: string): boolean {
+  const lower = caption.toLowerCase();
+  return (
+    /grocery\s+(shopping|haul)/.test(lower) ||
+    /#wieiad\b/.test(lower) ||
+    /\bwieiad\b/.test(lower) ||
+    /#cookingfail\b/.test(lower) ||
+    /#tastetest\b/.test(lower) ||
+    /#foodfail\b/.test(lower) ||
+    /espresso at home/.test(lower) ||
+    /#espresso\b/.test(lower) ||
+    /#coffeetiktok\b/.test(lower)
+  );
+}
+
+export function isLikelyRecipeCaption(caption: string): boolean {
+  if (!caption.trim() || isLikelyNonRecipeCaption(caption)) return false;
+  if (/what you['']ll need|ingredients\s*:/i.test(caption)) return true;
+  const hasSteps = /(?:^|\n)\s*\d+\.\s+\S/.test(caption);
+  const hasFoodMeasures =
+    /(\d+\/\d+|\d+)\s*(cup|cups|tbsp|tsp|lb|lbs|oz|clove|cloves|pkg|package)/i.test(
+      caption,
+    ) ||
+    /\b(tablespoon|teaspoon|pound|ounce|minute|minutes|simmer|bake|roast|air fryer|broil)\b/i.test(
+      caption,
+    );
+  return hasSteps && hasFoodMeasures;
+}
+
+export function extractTitleFromCaption(caption: string): string {
+  const ingredientsSplit = caption.split(
+    /what you['']ll need:?|ingredients\s*:/i,
+  )[0];
+  const intro = stripHashtagsAndMentions(ingredientsSplit ?? caption);
+  const firstSentence = intro.split(/[.!?]/)[0]?.trim() ?? intro;
+  const withoutThe = firstSentence.replace(/^the\s+/i, "");
+  const beforeVerb =
+    withoutThe.split(/\s+(?:is|are|have|has|was|will|makes)\s+/i)[0]?.trim() ??
+    withoutThe;
+
+  if (beforeVerb.length >= 8 && beforeVerb.length <= 72) {
+    return titleCase(beforeVerb);
+  }
+  if (firstSentence.length <= 72) {
+    return titleCase(firstSentence);
+  }
+  return titleCase(firstSentence.slice(0, 68).trim());
+}
+
+export function parseIngredientsFromCaption(caption: string): string[] {
+  const match = caption.match(/what you['']ll need:?|ingredients\s*:/i);
+  if (!match || match.index == null) return [];
+
+  const afterHeader = caption.slice(match.index + match[0].length);
+  const stepsMatch = afterHeader.match(/(?:^|\n)\s*\d+\.\s+/);
+  const ingredientsBlock = stepsMatch?.index
+    ? afterHeader.slice(0, stepsMatch.index)
+    : afterHeader;
+
+  const lines = ingredientsBlock.split(/\n/);
+  const ingredients: string[] = [];
+
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (/^\[[^\]]+\]$/.test(line)) continue;
+    if (/^recipe below/i.test(line)) continue;
+    ingredients.push(line);
+  }
+
+  return ingredients;
+}
+
+export function parseInstructionsFromCaption(caption: string): string[] {
+  const matches = [...caption.matchAll(/(?:^|\n)\s*(\d+)\.\s*([^\n]+)/g)];
+  return matches
+    .map((m) => m[2]?.trim())
+    .filter((s): s is string => Boolean(s && s.length > 3));
+}
+
+export function parseRecipeCaption(caption: string): {
+  title: string;
+  excerpt: string;
+  ingredients: string[];
+  instructions: string[];
+} | null {
+  if (!isLikelyRecipeCaption(caption)) return null;
+
+  const ingredients = parseIngredientsFromCaption(caption);
+  const instructions = parseInstructionsFromCaption(caption);
+  const title = extractTitleFromCaption(caption);
+
+  if (ingredients.length === 0 && instructions.length === 0) return null;
+
+  const intro = caption.split(/what you['']ll need:?|ingredients\s*:/i)[0]?.trim();
+  const excerptSource = stripHashtagsAndMentions(intro ?? caption)
+    .split(/[.!?]/)[0]
+    ?.trim();
+  const excerpt =
+    excerptSource && excerptSource.length > 20
+      ? excerptSource.slice(0, 220)
+      : `${title} — from Instagram.`;
+
+  return { title, excerpt, ingredients, instructions };
+}
+
+function imageFilenameForSlug(slug: string): string {
+  return `${slug}.jpg`;
+}
+
+export function buildParsedRecipeFromPost(
+  post: InstagramPostForRecipes,
+): ParsedInstagramRecipe | null {
+  const parsed = parseRecipeCaption(post.caption);
+  if (!parsed) return null;
+
+  const slug = slugifyRecipeTitle(parsed.title);
+  const alt =
+    post.accessibilityCaption?.trim() ||
+    `${parsed.title} — photo from Instagram`;
+
+  const recipe: ParsedInstagramRecipe = {
+    source: {
+      instagram_url: post.postUrl,
+      shortcode: post.shortcode,
+      likes: post.likes,
+      is_video: post.isVideo,
+    },
+    suggested_slug: slug,
+    title: parsed.title,
+    excerpt: parsed.excerpt,
+    caption_raw: post.caption,
+    ingredients: parsed.ingredients,
+    instructions: parsed.instructions,
+  };
+
+  if (post.displayUrl) {
+    recipe.featured_image = {
+      url: post.displayUrl,
+      alt,
+      filename: imageFilenameForSlug(slug),
+    };
+  }
+
+  return recipe;
+}
+
+/** Looser parse when caption has steps/ingredients but fails strict recipe heuristics. */
+export function buildParsedRecipeFromPostLenient(
+  post: InstagramPostForRecipes,
+): ParsedInstagramRecipe | null {
+  const strict = buildParsedRecipeFromPost(post);
+  if (strict) return strict;
+
+  const ingredients = parseIngredientsFromCaption(post.caption);
+  const instructions = parseInstructionsFromCaption(post.caption);
+  if (ingredients.length === 0 && instructions.length === 0) return null;
+
+  const title = extractTitleFromCaption(post.caption);
+  const slug = slugifyRecipeTitle(title);
+  const alt =
+    post.accessibilityCaption?.trim() ||
+    `${title} — photo from Instagram`;
+
+  const recipe: ParsedInstagramRecipe = {
+    source: {
+      instagram_url: post.postUrl,
+      shortcode: post.shortcode,
+      likes: post.likes,
+      is_video: post.isVideo,
+    },
+    suggested_slug: slug,
+    title,
+    excerpt: `${title} — imported from Instagram.`,
+    caption_raw: post.caption,
+    ingredients,
+    instructions,
+  };
+
+  if (post.displayUrl) {
+    recipe.featured_image = {
+      url: post.displayUrl,
+      alt,
+      filename: imageFilenameForSlug(slug),
+    };
+  }
+
+  return recipe;
+}

package/src/media-preview.ts

@@ -0,0 +1,28 @@
+/** Fixed JPEG header Instagram strips from `media_preview` payloads. */
+const JPEG_PREVIEW_TEMPLATE =
+  "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEABsaGikdKUEmJkFCLy8vQkc/Pj4/R0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0cBHSkpNCY0PygoP0c/NT9HR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR//AABEIABQAKgMBIgACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AA==";
+
+/** Decode Instagram's compact `media_preview` field into JPEG bytes. */
+export function decodeMediaPreview(previewBase64: string): Uint8Array | undefined {
+  try {
+    const binary = atob(previewBase64);
+    if (binary.length < 4) return undefined;
+
+    const width = binary.charCodeAt(1);
+    const height = binary.charCodeAt(2);
+    const body = binary.slice(3);
+    const headerBinary = atob(JPEG_PREVIEW_TEMPLATE);
+    const header = headerBinary.split("");
+    header[160] = String.fromCharCode(height);
+    header[162] = String.fromCharCode(width);
+
+    const jpeg = header.join("") + body;
+    const bytes = new Uint8Array(jpeg.length);
+    for (let i = 0; i < jpeg.length; i++) {
+      bytes[i] = jpeg.charCodeAt(i);
+    }
+    return bytes;
+  } catch {
+    return undefined;
+  }
+}

package/src/parse-instagram-post.ts

@@ -0,0 +1,386 @@
+const INSTAGRAM_POST_RE =
+  /(?:https?:\/\/)?(?:www\.)?instagram\.com\/(?:p|reel|tv)\/([A-Za-z0-9_-]+)/i;
+
+import {
+  extractOwnerUsername,
+  fetchProfileDisplayUrl,
+} from "./instagram-profile-image.js";
+import { scoreInstagramImageUrl } from "./instagram-image-url.js";
+
+const BROWSER_UA =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+
+const HTML_ENTITIES: Record<string, string> = {
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'",
+  "&#x2019;": "'",
+  "&#x2018;": "'",
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&#10;": "\n",
+  "&#13;": "\r",
+};
+
+export function parseInstagramPostUrl(raw: string): {
+  shortcode: string;
+  postUrl: string;
+} {
+  const trimmed = raw.trim();
+  const match = INSTAGRAM_POST_RE.exec(trimmed);
+  if (!match?.[1]) {
+    throw new Error(
+      "Paste a valid Instagram post URL (e.g. https://www.instagram.com/p/SHORTCODE/).",
+    );
+  }
+
+  const shortcode = match[1];
+  return {
+    shortcode,
+    postUrl: `https://www.instagram.com/p/${shortcode}/`,
+  };
+}
+
+export function decodeHtmlEntities(text: string): string {
+  let out = text;
+  for (const [entity, char] of Object.entries(HTML_ENTITIES)) {
+    out = out.split(entity).join(char);
+  }
+  out = out.replace(/&#(\d+);/g, (_, code) =>
+    String.fromCharCode(Number(code)),
+  );
+  out = out.replace(/&#x([0-9a-f]+);/gi, (_, hex) =>
+    String.fromCharCode(parseInt(hex, 16)),
+  );
+  return out;
+}
+
+const EMBEDDED_IMAGE_PATTERNS = [
+  /"display_url":"((?:https?:)?\\?\/\\?\/[^"\\]+)"/g,
+  /"display_url":"(https?:[^"\\]+)"/g,
+  /"thumbnail_src":"(https?:[^"\\]+)"/g,
+] as const;
+
+function decodeEmbeddedUrl(raw: string): string | undefined {
+  const normalized = raw.replaceAll("\\/", "/");
+  const url = decodeHtmlEntities(normalized).trim();
+  if (!url.startsWith("http")) return undefined;
+  if (/\.mp4(\?|$)|video\//i.test(url)) return undefined;
+  if (!url.includes("cdninstagram") && !url.includes("fbcdn.net")) {
+    return undefined;
+  }
+  return url;
+}
+
+/** Collect display_url / thumbnail_src values from Instagram's embedded post JSON. */
+export function extractEmbeddedImageUrls(html: string): string[] {
+  const seen = new Set<string>();
+  const urls: string[] = [];
+
+  for (const pattern of EMBEDDED_IMAGE_PATTERNS) {
+    for (const match of html.matchAll(pattern)) {
+      const decoded = decodeEmbeddedUrl(match[1] ?? "");
+      if (!decoded || seen.has(decoded)) continue;
+      seen.add(decoded);
+      urls.push(decoded);
+    }
+  }
+
+  return urls;
+}
+
+export { isInstagramVideoCoverUrl, scoreInstagramImageUrl } from "./instagram-image-url.js";
+
+type ImageCandidate = { url: string; width?: number; height?: number };
+
+export function extractImageVersionCandidates(html: string): ImageCandidate[] {
+  const seen = new Set<string>();
+  const out: ImageCandidate[] = [];
+  const itemRe =
+    /\{"height":(\d+),"url":"((?:https?:)?\\?\/\\?\/[^"\\]+)","width":(\d+)\}/g;
+
+  for (const match of html.matchAll(itemRe)) {
+    const normalized = (match[2] ?? "").replaceAll("\\/", "/");
+    const url = decodeHtmlEntities(normalized).trim();
+    if (!url.startsWith("http") || seen.has(url)) continue;
+    seen.add(url);
+    out.push({
+      url,
+      width: Number(match[3]),
+      height: Number(match[1]),
+    });
+  }
+
+  return out;
+}
+
+export function pickBestInstagramImageUrl(
+  candidates: string[] | ImageCandidate[],
+): string | undefined {
+  const normalized: ImageCandidate[] = candidates.map((c) =>
+    typeof c === "string" ? { url: c } : c,
+  );
+
+  const ranked = normalized
+    .map((entry) => ({
+      url: entry.url,
+      score: scoreInstagramImageUrl(entry.url, {
+        width: entry.width,
+        height: entry.height,
+      }),
+    }))
+    .filter((entry) => entry.score >= 0)
+    .sort((a, b) => b.score - a.score);
+
+  return ranked[0]?.url;
+}
+
+/** @deprecated Use extractEmbeddedImageUrls + pickBestInstagramImageUrl */
+export function extractEmbeddedImageUrl(html: string): string | undefined {
+  return pickBestInstagramImageUrl(extractEmbeddedImageUrls(html));
+}
+
+/**
+ * Resolve the post's feed image (same class of URL as brand-bootstrap display_url).
+ * Never uses og:video. Uses og:image only when no embedded display_url exists.
+ */
+export function resolvePostImageUrl(
+  html: string,
+  fallbacks?: { ogImage?: string; isVideo?: boolean },
+): string | undefined {
+  const embedded = extractEmbeddedImageUrls(html);
+  const bestEmbedded = pickBestInstagramImageUrl(embedded);
+  if (bestEmbedded) return bestEmbedded;
+
+  if (!fallbacks?.isVideo) {
+    const versioned = extractImageVersionCandidates(html);
+    const bestVersioned = pickBestInstagramImageUrl(versioned);
+    if (bestVersioned) return bestVersioned;
+  }
+
+  const ogImage = fallbacks?.ogImage
+    ? decodeHtmlEntities(fallbacks.ogImage)
+    : undefined;
+  if (
+    ogImage &&
+    !fallbacks?.isVideo &&
+    scoreInstagramImageUrl(ogImage) >= 0
+  ) {
+    return ogImage;
+  }
+
+  return undefined;
+}
+
+function extractMetaContent(html: string, property: string): string | undefined {
+  const escaped = property.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const patterns = [
+    new RegExp(`property="${escaped}"\\s+content="([^"]*)"`, "i"),
+    new RegExp(`content="([^"]*)"\\s+property="${escaped}"`, "i"),
+  ];
+  for (const re of patterns) {
+    const match = re.exec(html);
+    if (match?.[1]) return match[1];
+  }
+  return undefined;
+}
+
+async function primeInstagramSession(
+  fetchFn: (url: string, init?: RequestInit) => Promise<Response>,
+): Promise<void> {
+  await fetchFn("https://www.instagram.com/", {
+    method: "GET",
+    redirect: "follow",
+    headers: instagramFetchHeaders(),
+  });
+}
+
+function instagramFetchHeaders(referer?: string): HeadersInit {
+  return {
+    Accept:
+      "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Cache-Control": "no-cache",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": referer ? "same-origin" : "none",
+    "Upgrade-Insecure-Requests": "1",
+    "User-Agent": BROWSER_UA,
+    ...(referer ? { Referer: referer } : {}),
+  };
+}
+
+function instagramImageFetchHeaders(referer: string): HeadersInit {
+  return {
+    Accept: "image/avif,image/webp,image/apng,image/*,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Cache-Control": "no-cache",
+    Referer: referer,
+    "Sec-Fetch-Dest": "image",
+    "Sec-Fetch-Mode": "no-cors",
+    "Sec-Fetch-Site": "cross-site",
+    "User-Agent": BROWSER_UA,
+  };
+}
+
+function cookieHeaderFromResponse(res: Response): string | undefined {
+  const headers = res.headers;
+  const getSetCookie = headers.getSetCookie?.bind(headers);
+  const cookies = getSetCookie?.();
+  if (cookies?.length) {
+    return cookies.map((c) => c.split(";")[0]).join("; ");
+  }
+  const single = headers.get("set-cookie");
+  return single ? single.split(";")[0] : undefined;
+}
+
+async function downloadPostImage(
+  fetchFn: (url: string, init?: RequestInit) => Promise<Response>,
+  imageUrl: string,
+  postUrl: string,
+  cookieHeader?: string,
+): Promise<{ bytes: ArrayBuffer; contentType: string } | undefined> {
+  const headers: Record<string, string> = {
+    ...instagramImageFetchHeaders(postUrl),
+  } as Record<string, string>;
+  if (cookieHeader) {
+    headers.Cookie = cookieHeader;
+  }
+
+  const res = await fetchFn(imageUrl, { method: "GET", headers });
+
+  if (!res.ok) {
+    return undefined;
+  }
+
+  const contentType = res.headers.get("content-type") ?? "image/jpeg";
+  if (!contentType.startsWith("image/")) {
+    return undefined;
+  }
+
+  return { bytes: await res.arrayBuffer(), contentType };
+}
+
+/** Pull caption text from Instagram's og:description meta tag. */
+export function extractCaptionFromOgDescription(description: string): string {
+  const decoded = decodeHtmlEntities(description).trim();
+
+  const quoted = decoded.match(/:\s*["“]([\s\S]+?)["”]\.\s*$/);
+  if (quoted?.[1]) return quoted[1].trim();
+
+  const inline = decoded.match(/:\s*["“]([\s\S]+?)["”]/);
+  if (inline?.[1]) return inline[1].trim();
+
+  return decoded;
+}
+
+export type FetchedInstagramPost = {
+  shortcode: string;
+  postUrl: string;
+  caption: string;
+  displayUrl?: string;
+  isVideo: boolean;
+  /** Shown in admin when no usable thumbnail could be resolved. */
+  imageNotice?: string;
+  /** Image bytes downloaded in the same session as the post page (for media upload). */
+  imageBytes?: ArrayBuffer;
+  imageContentType?: string;
+};
+
+export type FetchInstagramPostOptions = {
+  /** Override owner handle for web_profile_info lookup (same as brand-bootstrap handle). */
+  instagramHandle?: string;
+};
+
+export async function fetchInstagramPost(
+  postUrl: string,
+  fetchFn: (url: string, init?: RequestInit) => Promise<Response>,
+  options: FetchInstagramPostOptions = {},
+): Promise<FetchedInstagramPost> {
+  const { shortcode } = parseInstagramPostUrl(postUrl);
+  const canonicalUrl = `https://www.instagram.com/p/${shortcode}/`;
+
+  await primeInstagramSession(fetchFn);
+
+  const res = await fetchFn(canonicalUrl, {
+    method: "GET",
+    redirect: "follow",
+    headers: instagramFetchHeaders("https://www.instagram.com/"),
+  });
+
+  if (!res.ok) {
+    throw new Error(
+      `Instagram returned HTTP ${res.status}. Try again in a few minutes if rate-limited.`,
+    );
+  }
+
+  const html = await res.text();
+  const ogDescription = extractMetaContent(html, "og:description");
+  if (!ogDescription) {
+    throw new Error(
+      "Could not read caption from the Instagram page. The post may be private or unavailable.",
+    );
+  }
+
+  const caption = extractCaptionFromOgDescription(ogDescription);
+  const ogVideo = extractMetaContent(html, "og:video");
+  const isVideo =
+    Boolean(ogVideo) ||
+    /"is_video":true/i.test(html) ||
+    /"__typename":"GraphVideo"/i.test(html) ||
+    /"media_type":2[,}]/i.test(html);
+
+  const cookieHeader = cookieHeaderFromResponse(res);
+  const ownerHandle =
+    options.instagramHandle ?? extractOwnerUsername(html);
+
+  let displayUrl: string | undefined;
+  let imageNotice: string | undefined;
+
+  // Same image source as init-brand-resources: web_profile_info → node.display_url
+  if (ownerHandle) {
+    const profile = await fetchProfileDisplayUrl(
+      fetchFn,
+      ownerHandle,
+      shortcode,
+    );
+    displayUrl = profile.url;
+    if (!displayUrl) {
+      if (profile.rateLimited) {
+        imageNotice =
+          "Instagram rate-limited the profile API (HTTP 429). The recipe was parsed without a featured image — upload one manually, or try Convert again in a few minutes.";
+      } else if (profile.shortcodeMissing) {
+        imageNotice =
+          "This post was not found in the latest profile grid (Instagram only returns ~12 posts). Import without a featured image and upload one manually.";
+      }
+    }
+  }
+
+  let imageBytes: ArrayBuffer | undefined;
+  let imageContentType: string | undefined;
+  if (displayUrl) {
+    const downloaded = await downloadPostImage(
+      fetchFn,
+      displayUrl,
+      canonicalUrl,
+      cookieHeader,
+    );
+    imageBytes = downloaded?.bytes;
+    imageContentType = downloaded?.contentType;
+  }
+
+  return {
+    shortcode,
+    postUrl: canonicalUrl,
+    caption,
+    displayUrl,
+    isVideo,
+    imageNotice,
+    imageBytes,
+    imageContentType,
+  };
+}
+
+export const instagramBrowserUserAgent = BROWSER_UA;
+export { instagramFetchHeaders, primeInstagramSession };