ultra-igdl 1.0.0

package/dist/index.js

@@ -0,0 +1,3270 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/logger.ts
+function shouldLog(level) {
+  if (verboseEnabled && level === "debug") return true;
+  return LEVELS[level] >= LEVELS[globalLevel];
+}
+var globalLevel, verboseEnabled, LEVELS, logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    globalLevel = "info";
+    verboseEnabled = false;
+    LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    };
+    logger = {
+      debug(...args) {
+        if (shouldLog("debug")) console.debug("[ultra-igdl]", ...args);
+      },
+      info(...args) {
+        if (shouldLog("info")) console.info("[ultra-igdl]", ...args);
+      },
+      warn(...args) {
+        if (shouldLog("warn")) console.warn("[ultra-igdl]", ...args);
+      },
+      error(...args) {
+        if (shouldLog("error")) console.error("[ultra-igdl]", ...args);
+      }
+    };
+  }
+});
+
+// src/utils/caption-normalize.ts
+function unescapeCaptionEscapes(text) {
+  let cur = text;
+  for (let i = 0; i < 4; i++) {
+    const next = cur.replace(/\\+u000d\\+u000a/gi, "\n").replace(/\\+u000a/gi, "\n").replace(/\\+u000d/gi, "\n").replace(/\\+r\\+n/gi, "\n").replace(/\\+n/g, "\n").replace(/\\+r/g, "\n");
+    if (next === cur) break;
+    cur = next;
+  }
+  return cur.replace(/\u2028/g, "\n").replace(/\u2029/g, "\n");
+}
+function normalizeCaptionText(raw) {
+  if (!raw) return "";
+  let text = unescapeCaptionEscapes(decodeHtmlEntities(raw));
+  text = text.replace(/^\s+/, "").replace(/\s+$/, "");
+  text = text.replace(/^["'\u201c\u201d]+|["'\u201d\u201c]+$/g, "");
+  return text;
+}
+function cleanInstagramCaptionLayout(text) {
+  const lines = text.split(/\r?\n/);
+  const kept = lines.map((line) => line.trim()).filter((line) => line && !/^\.+$/.test(line) && !/^[\u2026…]+$/.test(line));
+  return kept.join(" ").replace(/\s+/g, " ").trim();
+}
+function normalizePostCaptionText(raw) {
+  return cleanInstagramCaptionLayout(normalizeCaptionText(raw));
+}
+var init_caption_normalize = __esm({
+  "src/utils/caption-normalize.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_parser();
+  }
+});
+
+// src/utils/engagement.ts
+function normalizeInstagramQuotes(raw) {
+  return raw.replace(/[\u201c\u201d\u201e\u2033\u2036]/g, '"').replace(/[\u2018\u2019\u2032]/g, "'").trim();
+}
+function parseCount(token) {
+  const m = token.trim().match(/^([\d.]+)\s*([KMB])?$/i);
+  if (!m) return void 0;
+  let n = parseFloat(m[1]);
+  const suffix = (m[2] ?? "").toUpperCase();
+  if (suffix === "K") n *= 1e3;
+  else if (suffix === "M") n *= 1e6;
+  else if (suffix === "B") n *= 1e9;
+  return Math.round(n);
+}
+function extractEngagementCounts(statsSegment) {
+  const engagement = {};
+  const likes = statsSegment.match(/([\d.]+[KMB]?)\s+likes?/i);
+  const comments = statsSegment.match(/([\d.]+[KMB]?)\s+comments?/i);
+  const views = statsSegment.match(/([\d.]+[KMB]?)\s+views?/i);
+  const shares = statsSegment.match(/([\d.]+[KMB]?)\s+shares?/i);
+  if (likes) engagement.likes = parseCount(likes[1]);
+  if (comments) engagement.comments = parseCount(comments[1]);
+  if (views) engagement.views = parseCount(views[1]);
+  if (shares) engagement.shares = parseCount(shares[1]);
+  return engagement;
+}
+function parseInstagramDescription(raw) {
+  const text = normalizeInstagramQuotes(raw);
+  const engagement = {};
+  let caption = text;
+  let username = "";
+  const quoted = text.match(
+    /^([\d\s,KMB.likescommentsviews]+?)\s*-\s*@?([\w.]+)\s+on\s+[\s\S]+?:\s*["']([\s\S]+)["']\s*\.?\s*$/i
+  );
+  if (quoted) {
+    Object.assign(engagement, extractEngagementCounts(quoted[1]));
+    username = quoted[2];
+    caption = normalizeCaptionText(quoted[3].trim());
+    return { caption, username, engagement };
+  }
+  const colonBody = text.match(
+    /^([\d\s,KMB.likescommentsviews]+?)\s*-\s*@?([\w.]+)\s+on\s+([^:]+):\s*([\s\S]+)\s*$/i
+  );
+  if (colonBody) {
+    Object.assign(engagement, extractEngagementCounts(colonBody[1]));
+    username = colonBody[2];
+    caption = normalizeCaptionText(
+      colonBody[4].replace(/^["']|["']$/g, "").replace(/\s*\.\s*$/, "").trim()
+    );
+    return { caption, username, engagement };
+  }
+  if (!/\s+on\s+[\w\s\d,]+:\s*/i.test(text) && /^\d[\d.KMB,\s]*(?:likes?|comments?|views?)/i.test(text)) {
+    Object.assign(engagement, extractEngagementCounts(text));
+    caption = "";
+    engagement.raw = text;
+  }
+  return { caption, username, engagement };
+}
+function parseInstagramTitle(raw) {
+  const text = raw.trim();
+  let username = "";
+  let caption = "";
+  const highlight = text.match(/^(.+?)\s*=\s*@([\w.]+)/);
+  if (highlight) {
+    caption = highlight[1].trim();
+    username = highlight[2];
+    return { username, caption };
+  }
+  const paren = text.match(/\(@([\w.]+)\)/);
+  if (paren) username = paren[1];
+  const reel = text.match(/^(.+?)\s*\(@([\w.]+)\)\s*•/);
+  if (reel) {
+    caption = "";
+    username = reel[2];
+    return { username, caption };
+  }
+  const onIg = text.match(/^(.+?)\s+on Instagram/i);
+  if (onIg && !text.toLowerCase().includes("watch this story")) {
+    const part = onIg[1].trim();
+    const at = part.match(/@([\w.]+)/);
+    if (at) username = at[1];
+    else caption = part;
+  }
+  const atOnly = text.match(/@([\w.]+)/);
+  if (!username && atOnly) username = atOnly[1];
+  return { username, caption };
+}
+var init_engagement = __esm({
+  "src/utils/engagement.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_caption_normalize();
+  }
+});
+
+// src/utils/caption.ts
+function isEngagementPrefixedCaption(text) {
+  return /^\d[\d.KMB,\s]*(?:likes?|comments?|views?)/i.test(text) && /\s+on\s+[\w\s\d,.]+:\s*/i.test(text);
+}
+function captionWithoutEngagementPrefix(raw) {
+  const text = normalizeCaptionText(raw);
+  if (!text) return "";
+  if (!isEngagementPrefixedCaption(text)) return text;
+  return normalizeCaptionText(parseInstagramDescription(text).caption);
+}
+function pickBestCaption(...candidates) {
+  let best = "";
+  for (const raw of candidates) {
+    if (!raw) continue;
+    const text = captionWithoutEngagementPrefix(raw);
+    if (!text) continue;
+    if (text.length > best.length) best = text;
+  }
+  return best;
+}
+function scrapeCaptionFromHtml(html) {
+  if (!html) return "";
+  const found = [];
+  const patterns = [
+    /"caption"\s*:\s*\{[^}]*"text"\s*:\s*"((?:\\.|[^"\\])*)"/g,
+    /"edge_media_to_caption"\s*:\s*\{[^}]*"text"\s*:\s*"((?:\\.|[^"\\])*)"/g
+  ];
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(html)) !== null) {
+      try {
+        const text = JSON.parse(`"${m[1]}"`);
+        if (text && !isEngagementPrefixedCaption(text)) found.push(text);
+      } catch {
+      }
+    }
+  }
+  return pickBestCaption(...found);
+}
+function resolveCaptionForContent(type, sources) {
+  const embed = sources.embed ? normalizeCaptionText(sources.embed) : "";
+  const scraped = sources.scraped ? captionWithoutEngagementPrefix(sources.scraped) : "";
+  const extracted = sources.extracted ? captionWithoutEngagementPrefix(sources.extracted) : "";
+  const og = sources.og ? captionWithoutEngagementPrefix(sources.og) : "";
+  if (type === "reel" || type === "tv") {
+    if (embed) return embed;
+    return pickBestCaption(scraped, extracted, og);
+  }
+  return pickBestCaption(scraped, embed, extracted, og);
+}
+function extractCaptionFromApiItem(item) {
+  const cap = item.caption;
+  if (cap && typeof cap.text === "string") return normalizeCaptionText(cap.text);
+  if (typeof item.caption_text === "string") return normalizeCaptionText(item.caption_text);
+  return "";
+}
+var init_caption = __esm({
+  "src/utils/caption.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_engagement();
+    init_caption_normalize();
+    init_caption_normalize();
+  }
+});
+
+// src/core/parser.ts
+var parser_exports = {};
+__export(parser_exports, {
+  decodeEscapedUrl: () => decodeEscapedUrl,
+  decodeHtmlEntities: () => decodeHtmlEntities,
+  detectNotFound: () => detectNotFound,
+  detectRateLimit: () => detectRateLimit,
+  mergeExtracted: () => mergeExtracted,
+  needsVideoEmbedFallback: () => needsVideoEmbedFallback,
+  parseEmbedHtml: () => parseEmbedHtml,
+  parseHtml: () => parseHtml,
+  pickBestImage: () => pickBestImage,
+  pickBestVideo: () => pickBestVideo
+});
+import * as cheerio from "cheerio";
+function area(w, h) {
+  return (w ?? 0) * (h ?? 0);
+}
+function pickBestImage(candidates) {
+  if (!candidates.length) return null;
+  return candidates.reduce(
+    (best, cur) => area(cur.width, cur.height) > area(best.width, best.height) ? cur : best
+  );
+}
+function pickBestVideo(candidates) {
+  if (!candidates.length) return null;
+  return candidates.reduce((best, cur) => {
+    const bestScore = area(best.width, best.height) + (best.duration ?? 0);
+    const curScore = area(cur.width, cur.height) + (cur.duration ?? 0);
+    return curScore > bestScore ? cur : best;
+  });
+}
+function decodeEscapedUrl(url) {
+  let decoded = url.replace(/\\u0026/g, "&").replace(/\\u00253D/g, "=").replace(/\\u003c/g, "<").replace(/\\u003e/g, ">").replace(/&amp;/g, "&");
+  while (decoded.includes("\\/") || decoded.includes("\\\\")) {
+    decoded = decoded.replace(/\\+\//g, "/").replace(/\\\\/g, "\\");
+  }
+  decoded = decoded.replace(/\\+$/, "").replace(/\\/g, "");
+  if (decoded.startsWith("https:/") && !decoded.startsWith("https://")) {
+    decoded = decoded.replace("https:/", "https://");
+  }
+  return decoded;
+}
+function decodeHtmlEntities(text) {
+  return text.replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(
+    /&#x([0-9a-f]+);/gi,
+    (_, hex) => String.fromCodePoint(parseInt(hex, 16))
+  ).replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(parseInt(dec, 10)));
+}
+function isProfileOrStaticCdn(url) {
+  return url.includes("static.cdninstagram.com") || /\/t51\.2885-19\//.test(url) || /stp=dst-jpg_s\d+x\d+/.test(url);
+}
+function extractJsonLd(html) {
+  const $ = cheerio.load(html);
+  const scripts = $('script[type="application/ld+json"]');
+  for (let i = 0; i < scripts.length; i++) {
+    try {
+      const raw = $(scripts[i]).html();
+      if (!raw) continue;
+      const data = JSON.parse(raw);
+      const items = Array.isArray(data) ? data : [data];
+      const media = [];
+      let caption = "";
+      let username = "";
+      for (const item of items) {
+        if (typeof item !== "object" || !item) continue;
+        const obj = item;
+        if (typeof obj.description === "string") {
+          caption = pickBestCaption(caption, obj.description);
+        }
+        if (typeof obj.author === "object" && obj.author) {
+          const author = obj.author;
+          if (typeof author.name === "string") username = author.name;
+          if (typeof author.identifier === "string") {
+            username = author.identifier.replace(/^@/, "");
+          }
+        }
+        const contentUrl = obj.contentUrl ?? obj.embedUrl;
+        if (typeof contentUrl === "string") {
+          const isVideo = obj["@type"] === "VideoObject" || String(contentUrl).includes(".mp4");
+          media.push({
+            type: isVideo ? "video" : "image",
+            url: decodeEscapedUrl(contentUrl),
+            thumbnail: typeof obj.thumbnailUrl === "string" ? decodeEscapedUrl(obj.thumbnailUrl) : void 0,
+            width: typeof obj.width === "number" ? obj.width : void 0,
+            height: typeof obj.height === "number" ? obj.height : void 0,
+            duration: typeof obj.duration === "string" ? parseDuration(obj.duration) : void 0
+          });
+        }
+        if (Array.isArray(obj.image)) {
+          for (const img of obj.image) {
+            if (typeof img === "string") {
+              media.push({ type: "image", url: decodeEscapedUrl(img) });
+            } else if (img && typeof img === "object") {
+              const im = img;
+              if (typeof im.url === "string") {
+                media.push({
+                  type: "image",
+                  url: decodeEscapedUrl(im.url),
+                  width: typeof im.width === "number" ? im.width : void 0,
+                  height: typeof im.height === "number" ? im.height : void 0
+                });
+              }
+            }
+          }
+        } else if (typeof obj.image === "string") {
+          media.push({ type: "image", url: decodeEscapedUrl(obj.image) });
+        }
+      }
+      if (media.length) {
+        logger.debug("Layer 1 (JSON-LD) succeeded");
+        return { media: dedupeMedia(media), caption, username };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function parseDuration(iso) {
+  const match = iso.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/);
+  if (!match) return void 0;
+  const h = parseInt(match[1] ?? "0", 10);
+  const m = parseInt(match[2] ?? "0", 10);
+  const s = parseInt(match[3] ?? "0", 10);
+  return h * 3600 + m * 60 + s;
+}
+function extractWindowJson(html, marker) {
+  const idx = html.indexOf(marker);
+  if (idx === -1) return null;
+  const start = html.indexOf("{", idx + marker.length);
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = start; i < html.length; i++) {
+    const ch = html[i];
+    if (inString) {
+      if (escape) escape = false;
+      else if (ch === "\\") escape = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        try {
+          return JSON.parse(html.slice(start, i + 1));
+        } catch {
+          return null;
+        }
+      }
+    }
+  }
+  return null;
+}
+function mediaFromNode(node) {
+  const results = [];
+  const isVideo = node.is_video === true || node.media_type === 2 || node.__typename === "GraphVideo";
+  if (isVideo && node.video_versions) {
+    const versions = node.video_versions;
+    const best = versions.reduce(
+      (a, b) => (b.width ?? 0) > (a.width ?? 0) ? b : a
+    );
+    if (typeof best.url === "string") {
+      results.push({
+        type: "video",
+        url: decodeEscapedUrl(best.url),
+        width: best.width,
+        height: best.height,
+        duration: node.video_duration ?? node.duration,
+        thumbnail: extractThumbnail(node)
+      });
+    }
+  } else if (node.image_versions2) {
+    const candidates = node.image_versions2.candidates;
+    if (candidates?.length) {
+      const best = candidates.reduce(
+        (a, b) => (b.width ?? 0) > (a.width ?? 0) ? b : a
+      );
+      if (typeof best.url === "string") {
+        results.push({
+          type: "image",
+          url: decodeEscapedUrl(best.url),
+          width: best.width,
+          height: best.height
+        });
+      }
+    }
+  } else if (node.display_url) {
+    results.push({
+      type: "image",
+      url: decodeEscapedUrl(String(node.display_url)),
+      width: node.original_width,
+      height: node.original_height
+    });
+  } else if (node.display_resources) {
+    const resources = node.display_resources;
+    const best = resources.reduce(
+      (a, b) => (b.config_width ?? 0) > (a.config_width ?? 0) ? b : a
+    );
+    if (typeof best.src === "string") {
+      results.push({
+        type: "image",
+        url: decodeEscapedUrl(best.src),
+        width: best.config_width,
+        height: best.config_height
+      });
+    }
+  }
+  return results;
+}
+function extractThumbnail(node) {
+  if (typeof node.thumbnail_src === "string") return decodeEscapedUrl(node.thumbnail_src);
+  const candidates = node.image_versions2?.candidates;
+  if (candidates?.[0] && typeof candidates[0].url === "string") {
+    return decodeEscapedUrl(candidates[0].url);
+  }
+  return void 0;
+}
+function walkForMedia(obj, media, meta) {
+  if (!obj || typeof obj !== "object") return;
+  if (Array.isArray(obj)) {
+    for (const item of obj) walkForMedia(item, media, meta);
+    return;
+  }
+  const record = obj;
+  if (typeof record.caption === "object" && record.caption) {
+    const cap = record.caption;
+    if (typeof cap.text === "string") {
+      meta.caption = pickBestCaption(meta.caption, normalizeCaptionText(cap.text));
+    }
+  } else if (typeof record.edge_media_to_caption === "object") {
+    const edges = record.edge_media_to_caption.edges;
+    const text = edges?.[0]?.node;
+    if (typeof text?.text === "string") {
+      meta.caption = pickBestCaption(meta.caption, normalizeCaptionText(text.text));
+    }
+  }
+  if (typeof record.owner === "object" && record.owner) {
+    const owner = record.owner;
+    if (typeof owner.username === "string") meta.username = owner.username;
+  }
+  const carouselSlides = [];
+  if (Array.isArray(record.carousel_media)) {
+    for (const item of record.carousel_media) {
+      if (item && typeof item === "object") {
+        carouselSlides.push(item);
+      }
+    }
+  }
+  if (record.edge_sidecar_to_children) {
+    const edges = record.edge_sidecar_to_children.edges;
+    for (const edge of edges ?? []) {
+      const node = edge.node;
+      if (node) carouselSlides.push(node);
+    }
+  }
+  if (carouselSlides.length > 0) {
+    for (const slide of carouselSlides) {
+      media.push(...mediaFromNode(slide));
+    }
+  } else if (record.shortcode || record.display_url || record.video_versions || record.image_versions2 || record.is_video !== void 0) {
+    media.push(...mediaFromNode(record));
+  }
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "carousel_media" || key === "edge_sidecar_to_children") continue;
+    if (value && typeof value === "object") walkForMedia(value, media, meta);
+  }
+}
+function extractAdditionalData(html) {
+  const data = extractWindowJson(html, "window.__additionalDataLoaded(");
+  if (!data) return null;
+  const media = [];
+  const meta = { caption: "", username: "" };
+  walkForMedia(data, media, meta);
+  if (media.length) {
+    logger.debug("Layer 2 (__additionalDataLoaded) succeeded");
+    return { media: dedupeMedia(media), caption: meta.caption, username: meta.username };
+  }
+  return null;
+}
+function extractSharedData(html) {
+  const data = extractWindowJson(html, "window._sharedData");
+  if (!data) return null;
+  const media = [];
+  const meta = { caption: "", username: "" };
+  walkForMedia(data, media, meta);
+  if (media.length) {
+    logger.debug("Layer 3 (_sharedData) succeeded");
+    return { media: dedupeMedia(media), caption: meta.caption, username: meta.username };
+  }
+  return null;
+}
+function extractNextData(html) {
+  const $ = cheerio.load(html);
+  const script = $("#__NEXT_DATA__").html();
+  if (!script) return null;
+  try {
+    const data = JSON.parse(script);
+    const media = [];
+    const meta = { caption: "", username: "" };
+    walkForMedia(data, media, meta);
+    if (media.length) {
+      logger.debug("Layer 4 (Next.js) succeeded");
+      return { media: dedupeMedia(media), caption: meta.caption, username: meta.username };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function extractOpenGraph(html) {
+  const $ = cheerio.load(html);
+  const media = [];
+  let caption = normalizeCaptionText(
+    decodeHtmlEntities(
+      $('meta[property="og:description"]').attr("content") ?? $('meta[name="description"]').attr("content") ?? ""
+    )
+  );
+  const ogTitle = decodeHtmlEntities($('meta[property="og:title"]').attr("content") ?? "");
+  let username = ogTitle.match(/\(@([^)]+)\)/)?.[1] ?? ogTitle.split("(@")[1]?.replace(")", "").trim() ?? "";
+  if (!username && ogTitle.includes(" on Instagram")) {
+    username = ogTitle.split(" on Instagram")[0]?.replace(/^.*@/, "").trim() ?? "";
+  }
+  if (!username && ogTitle.includes("@")) {
+    const m = ogTitle.match(/@([\w.]+)/);
+    if (m) username = m[1];
+  }
+  const ogVideo = decodeHtmlEntities(
+    $('meta[property="og:video:secure_url"], meta[property="og:video"]').attr("content") ?? ""
+  );
+  const ogImage = decodeHtmlEntities(
+    $('meta[property="og:image"]').attr("content") ?? $('meta[property="og:image:url"]').attr("content") ?? $('meta[name="twitter:image"]').attr("content") ?? ""
+  );
+  if (ogVideo) {
+    media.push({
+      type: "video",
+      url: decodeEscapedUrl(ogVideo),
+      thumbnail: ogImage ? decodeEscapedUrl(ogImage) : void 0
+    });
+  }
+  if (ogImage) {
+    const imageUrl = decodeEscapedUrl(ogImage);
+    const type = imageUrl.includes(".mp4") ? "video" : "image";
+    const isThumbForVideo = Boolean(ogVideo) && type === "image";
+    if (!isThumbForVideo && !media.some((m) => m.url === imageUrl) && (!isProfileOrStaticCdn(imageUrl) || !ogVideo)) {
+      media.push({ type, url: imageUrl });
+    } else if (ogVideo && imageUrl && !media[0]?.thumbnail) {
+      media[0].thumbnail = imageUrl;
+    }
+  }
+  if (media.length) {
+    logger.debug("Layer 5 (Open Graph) succeeded");
+    return { media: dedupeMedia(media), caption, username };
+  }
+  return null;
+}
+function extractScriptJson(html) {
+  const $ = cheerio.load(html);
+  const media = [];
+  const meta = { caption: "", username: "" };
+  $('script[type="application/json"]').each((_, el) => {
+    const raw = $(el).html();
+    if (!raw || raw.length < 500) return;
+    try {
+      const data = JSON.parse(raw);
+      walkForMedia(data, media, meta);
+    } catch {
+    }
+  });
+  if (media.length) {
+    logger.debug("Layer 5b (application/json scripts) succeeded");
+    return { media: dedupeMedia(media), caption: meta.caption, username: meta.username };
+  }
+  return null;
+}
+function parseEmbedHtml(html) {
+  const scriptResult = extractScriptJson(html);
+  if (scriptResult?.media.some((m) => m.type === "video")) {
+    return scriptResult;
+  }
+  const media = [];
+  const patterns = [
+    /video_url\\":\\"([^"]+)/g,
+    /"video_url":"(https?:[^"]+)"/g,
+    /playback_url\\":\\"([^"]+)/g,
+    /"playback_url":"(https?:[^"]+)"/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(html)) !== null) {
+      let url = decodeEscapedUrl(match[1]);
+      if (!url.startsWith("http")) url = `https://${url.replace(/^\/+/, "")}`;
+      if (url.includes(".mp4") || url.includes("fbcdn") || url.includes("cdninstagram")) {
+        media.push({ type: "video", url });
+      }
+    }
+  }
+  if (!media.length) return null;
+  return { media: dedupeMedia(media), caption: "", username: "" };
+}
+function extractDirectCdn(html) {
+  const media = [];
+  const found = /* @__PURE__ */ new Set();
+  const patterns = [
+    /https:\/\/scontent\.cdninstagram\.com\/[^"'\s<>\\&]+/g,
+    /https:\\\/\\\/scontent\.cdninstagram\.com\/[^"\\]+/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(html)) !== null) {
+      const url = decodeEscapedUrl(match[0]);
+      if (isProfileOrStaticCdn(url) || found.has(url)) continue;
+      found.add(url);
+      const type = url.includes(".mp4") ? "video" : "image";
+      media.push({ type, url });
+    }
+  }
+  if (media.length) {
+    logger.debug("Layer 6b (direct CDN) succeeded");
+    return { media: dedupeMedia(media), caption: "", username: "" };
+  }
+  return null;
+}
+function extractGraphQLFromPage(html) {
+  const docIdMatch = html.match(/"doc_id":"(\d+)"/);
+  const queryIdMatch = html.match(/"query_id":"(\d+)"/);
+  if (!docIdMatch && !queryIdMatch) return null;
+  const media = [];
+  const cdnPatterns = [
+    /"video_url":"([^"]+)"/g,
+    /"display_url":"([^"]+)"/g,
+    /"url":"(https:\\\/\\\/[^"]+?cdninstagram[^"]+)"/g
+  ];
+  for (const pattern of cdnPatterns) {
+    let match;
+    while ((match = pattern.exec(html)) !== null) {
+      const url = decodeEscapedUrl(match[1]);
+      if (url.includes(".mp4") || url.includes("video")) {
+        media.push({ type: "video", url });
+      } else if (url.includes("cdninstagram") || url.includes("fbcdn")) {
+        media.push({ type: "image", url });
+      }
+    }
+  }
+  if (media.length) {
+    logger.debug("Layer 6 (GraphQL discovery) succeeded");
+    return { media: dedupeMedia(media), caption: "", username: "" };
+  }
+  return null;
+}
+function extractFallback(html) {
+  const media = [];
+  const videoRegex = /"video_versions":\s*\[([^\]]+)\]/g;
+  const urlRegex = /"url":"(https?:\\\/\\\/[^"]+)"/g;
+  let block;
+  while ((block = videoRegex.exec(html)) !== null) {
+    const segment = block[1];
+    const urls = [];
+    let m;
+    const inner = /"url":"([^"]+)","width":(\d+)/g;
+    while ((m = inner.exec(segment)) !== null) {
+      urls.push({ url: decodeEscapedUrl(m[1]), width: parseInt(m[2], 10) });
+    }
+    if (urls.length) {
+      const best = urls.reduce((a, b) => b.width > a.width ? b : a);
+      media.push({ type: "video", url: best.url, width: best.width });
+    }
+  }
+  const imageCandidates = [];
+  const imgRegex = /"display_url":"([^"]+)"|"src":"(https?:\\\/\\\/[^"]+?)"/g;
+  let im;
+  while ((im = imgRegex.exec(html)) !== null) {
+    const url = decodeEscapedUrl(im[1] ?? im[2]);
+    if (url.includes("cdninstagram") || url.includes("fbcdn")) {
+      imageCandidates.push({ url, width: 0 });
+    }
+  }
+  const configRegex = /"src":"(https?:\\\/\\\/[^"]+)","config_width":(\d+)/g;
+  while ((im = configRegex.exec(html)) !== null) {
+    imageCandidates.push({
+      url: decodeEscapedUrl(im[1]),
+      width: parseInt(im[2], 10)
+    });
+  }
+  if (imageCandidates.length) {
+    const best = imageCandidates.reduce((a, b) => b.width > a.width ? b : a);
+    if (!media.some((m) => m.url === best.url)) {
+      media.push({ type: "image", url: best.url, width: best.width || void 0 });
+    }
+  }
+  if (!media.length) {
+    let m;
+    while ((m = urlRegex.exec(html)) !== null) {
+      const url = decodeEscapedUrl(m[1]);
+      if (url.includes(".mp4")) media.push({ type: "video", url });
+      else if (url.includes("cdninstagram")) media.push({ type: "image", url });
+    }
+  }
+  if (media.length) {
+    logger.debug("Layer 7 (fallback) succeeded");
+    return { media: dedupeMedia(media), caption: "", username: "" };
+  }
+  return null;
+}
+function dedupeMedia(media) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const item of media) {
+    const normalized = item.url.split("?")[0];
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    if (!item.url.startsWith("http")) continue;
+    if (item.url.includes("static.cdninstagram.com")) continue;
+    result.push(item);
+  }
+  return result.map((m) => ({
+    ...m,
+    url: decodeEscapedUrl(m.url)
+  }));
+}
+function mergeExtracted(primary, secondary) {
+  if (!primary && !secondary) return null;
+  if (!primary) return secondary;
+  if (!secondary) return primary;
+  const media = dedupeMedia([...primary.media, ...secondary.media]);
+  const tags = [.../* @__PURE__ */ new Set([...primary.tags ?? [], ...secondary.tags ?? []])];
+  return {
+    media,
+    caption: pickBestCaption(primary.caption, secondary.caption),
+    username: primary.username || secondary.username,
+    engagement: primary.engagement || secondary.engagement ? { ...secondary.engagement, ...primary.engagement } : void 0,
+    tags: tags.length ? tags : void 0,
+    isPrivate: primary.isPrivate || secondary.isPrivate
+  };
+}
+function needsVideoEmbedFallback(parsed, data) {
+  if (!data?.media.length) return parsed.type === "reel" || parsed.type === "tv";
+  if (parsed.type !== "reel" && parsed.type !== "tv") return false;
+  return !data.media.some((m) => m.type === "video");
+}
+function extractionComplete(data, contentType) {
+  if (data.media.some((m) => m.type === "video")) return true;
+  if (contentType === "post") {
+    const img = data.media.find((m) => m.type === "image");
+    if (!img) return false;
+    if (img.width && img.height && img.width > 640) return true;
+    const fromUrl = img.url.match(/stp=c[\d.]+?\.(\d+)\.(\d+)a/i);
+    if (fromUrl) {
+      const w = parseInt(fromUrl[1], 10);
+      return w > 640;
+    }
+    return false;
+  }
+  if (contentType === "reel" || contentType === "tv") {
+    return data.media.some((m) => m.type === "video");
+  }
+  return data.media.length > 0;
+}
+function parseHtml(html, contentType) {
+  const fast = contentType === "post" || contentType === "reel" || contentType === "tv" || contentType === "highlight" || contentType === "story";
+  const layers = fast ? [
+    extractOpenGraph,
+    extractScriptJson,
+    extractAdditionalData,
+    extractSharedData,
+    extractFallback
+  ] : [
+    extractScriptJson,
+    extractJsonLd,
+    extractAdditionalData,
+    extractSharedData,
+    extractNextData,
+    extractOpenGraph,
+    extractGraphQLFromPage,
+    extractDirectCdn,
+    extractFallback
+  ];
+  let merged = null;
+  for (const layer of layers) {
+    const result = layer(html);
+    if (result?.media.length) {
+      merged = mergeExtracted(merged, result);
+      if (fast && contentType !== "post" && merged && extractionComplete(merged, contentType)) {
+        break;
+      }
+    }
+  }
+  if (merged?.media.length) {
+    return upgradeMediaQuality(merged);
+  }
+  if (html.includes("login") && html.includes("Log in to Instagram")) {
+    return { media: [], caption: "", username: "", isPrivate: true };
+  }
+  return null;
+}
+function upgradeMediaQuality(data) {
+  const videos = data.media.filter((m) => m.type === "video");
+  const images = data.media.filter((m) => m.type === "image");
+  const upgraded = [];
+  const bestVideo = pickBestVideo(videos);
+  if (bestVideo) upgraded.push(bestVideo);
+  else if (videos[0]) upgraded.push(videos[0]);
+  for (const img of images) {
+    if (!upgraded.some((u) => u.url.split("?")[0] === img.url.split("?")[0])) {
+      upgraded.push(img);
+    }
+  }
+  if (!bestVideo && images.length > 1) {
+    const sorted = [...images].sort(
+      (a, b) => area(b.width, b.height) - area(a.width, a.height)
+    );
+    return { ...data, media: sorted };
+  }
+  return { ...data, media: upgraded.length ? upgraded : data.media };
+}
+function detectRateLimit(html) {
+  return html.includes("Please wait a few minutes") || html.includes("429 Too Many Requests") || html.includes("rate limit");
+}
+function detectNotFound(html, statusCode) {
+  return statusCode === 404 || html.includes("Sorry, this page isn't available") || html.includes("Page Not Found");
+}
+var init_parser = __esm({
+  "src/core/parser.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_caption();
+    init_caption_normalize();
+    init_logger();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/core/downloader.ts
+init_esm_shims();
+
+// src/types/index.ts
+init_esm_shims();
+
+// src/version.ts
+init_esm_shims();
+var PACKAGE_VERSION = "1.0.0";
+
+// src/types/index.ts
+var EXTRACTOR_NAME = "ultra-igdl";
+
+// src/network/client.ts
+init_esm_shims();
+
+// src/network/request.ts
+init_esm_shims();
+import { request } from "undici";
+
+// src/network/headers.ts
+init_esm_shims();
+var USER_AGENTS = [
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:133.0) Gecko/20100101 Firefox/133.0",
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0",
+  "Mozilla/5.0 (iPhone; CPU iPhone OS 17_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Mobile/15E148 Safari/604.1"
+];
+var ACCEPT_LANGUAGES = [
+  "en-US,en;q=0.9",
+  "en-GB,en;q=0.9",
+  "en-US,en;q=0.8,es;q=0.6"
+];
+var SEC_CH_UA = [
+  '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
+  '"Chromium";v="131", "Not_A Brand";v="24"'
+];
+var rotationIndex = 0;
+function rotateIndex(max) {
+  const idx = rotationIndex % max;
+  rotationIndex += 1;
+  return idx;
+}
+var MOBILE_UA = USER_AGENTS[5];
+function buildInstagramPageHeaders(_rotate = false) {
+  const ua = MOBILE_UA;
+  return {
+    "User-Agent": ua,
+    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+    // Do not request br — undici/IG combo returns stripped HTML without OG tags.
+    Referer: "https://www.instagram.com/"
+  };
+}
+function buildHeaders(url, rotate = true) {
+  if (url.includes("instagram.com") && !url.includes("cdninstagram") && !url.includes("fbcdn")) {
+    return buildInstagramPageHeaders(rotate);
+  }
+  const uaIdx = rotate ? rotateIndex(USER_AGENTS.length) : 0;
+  const langIdx = rotate ? rotateIndex(ACCEPT_LANGUAGES.length) : 0;
+  const secIdx = rotate ? rotateIndex(SEC_CH_UA.length) : 0;
+  return {
+    "User-Agent": USER_AGENTS[uaIdx],
+    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+    "Accept-Language": ACCEPT_LANGUAGES[langIdx],
+    "Accept-Encoding": "gzip, deflate, br",
+    "Cache-Control": "no-cache",
+    Pragma: "no-cache",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "none",
+    "Sec-Fetch-User": "?1",
+    "Upgrade-Insecure-Requests": "1",
+    "Sec-Ch-Ua": SEC_CH_UA[secIdx],
+    "Sec-Ch-Ua-Mobile": "?0",
+    "Sec-Ch-Ua-Platform": '"Windows"',
+    Referer: "https://www.instagram.com/",
+    Origin: "https://www.instagram.com",
+    ...url.includes("cdninstagram") || url.includes("fbcdn") ? { Referer: "https://www.instagram.com/" } : {}
+  };
+}
+function buildApiHeaders() {
+  const base = buildHeaders("https://www.instagram.com/");
+  return {
+    ...base,
+    "X-Requested-With": "XMLHttpRequest",
+    "X-IG-App-ID": "936619743392459",
+    "X-ASBD-ID": "129477",
+    Accept: "*/*"
+  };
+}
+
+// src/network/retry.ts
+init_esm_shims();
+var DEFAULT_RETRY_ON = (error, statusCode) => {
+  if (statusCode === 429 || statusCode === 503 || statusCode === 502) return true;
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return msg.includes("timeout") || msg.includes("econnreset") || msg.includes("socket") || msg.includes("network");
+  }
+  return false;
+};
+async function withRetry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    baseDelayMs = 300,
+    maxDelayMs = 8e3,
+    retryOn = DEFAULT_RETRY_ON
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      lastError = error;
+      const statusCode = error && typeof error === "object" && "statusCode" in error ? error.statusCode : void 0;
+      if (attempt >= maxRetries || !retryOn(error, statusCode)) {
+        throw error;
+      }
+      const jitter = Math.random() * 100;
+      const delay = Math.min(
+        baseDelayMs * Math.pow(2, attempt) + jitter,
+        maxDelayMs
+      );
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/network/pool.ts
+init_esm_shims();
+import { Agent, Pool } from "undici";
+var DEFAULT_CONNECTIONS = 100;
+var sharedAgent = null;
+function getAgent(maxConnections = DEFAULT_CONNECTIONS) {
+  if (!sharedAgent) {
+    sharedAgent = new Agent({
+      connections: maxConnections,
+      pipelining: 1,
+      keepAliveTimeout: 6e4,
+      keepAliveMaxTimeout: 12e4,
+      connect: { rejectUnauthorized: true }
+    });
+  }
+  return sharedAgent;
+}
+function getPoolStats() {
+  return {
+    connections: DEFAULT_CONNECTIONS,
+    pending: 0
+  };
+}
+
+// src/network/client.ts
+init_logger();
+var inFlight = /* @__PURE__ */ new Map();
+var inFlightCookie = /* @__PURE__ */ new Map();
+var HttpClient = class {
+  timeoutMs;
+  retries;
+  userAgentRotation;
+  constructor(options = {}) {
+    this.timeoutMs = options.timeoutMs ?? 8e3;
+    this.retries = options.retries ?? 2;
+    this.userAgentRotation = options.userAgentRotation ?? true;
+  }
+  async fetchWithCookie(url, cookie, dedupe = true) {
+    const key = `${url}\0${cookie.slice(0, 48)}`;
+    if (dedupe && inFlightCookie.has(key)) {
+      return inFlightCookie.get(key);
+    }
+    const promise = this.fetchWithCookieInternal(url, cookie);
+    if (dedupe) {
+      inFlightCookie.set(key, promise);
+      promise.finally(() => inFlightCookie.delete(key));
+    }
+    return promise;
+  }
+  async fetchWithCookieInternal(url, cookie) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await request(url, {
+        method: "GET",
+        headers: { ...buildInstagramPageHeaders(), Cookie: cookie },
+        signal: controller.signal
+      });
+      const body = await response.body.text();
+      const resHeaders = {};
+      for (const [key, value] of Object.entries(response.headers)) {
+        if (typeof value === "string") resHeaders[key] = value;
+        else if (Array.isArray(value)) resHeaders[key] = value.join(", ");
+      }
+      return { body, statusCode: response.statusCode, headers: resHeaders };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async fetch(url, dedupe = true) {
+    if (dedupe && inFlight.has(url)) {
+      return inFlight.get(url);
+    }
+    const promise = this.fetchInternal(url);
+    if (dedupe) {
+      inFlight.set(url, promise);
+      promise.finally(() => inFlight.delete(url));
+    }
+    return promise;
+  }
+  async fetchInternal(url) {
+    return withRetry(
+      async (attempt) => {
+        const headers = buildHeaders(url, this.userAgentRotation || attempt > 0);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+          logger.debug(`Fetching ${url} (attempt ${attempt + 1})`);
+          const usePool = url.includes("cdninstagram") || url.includes("fbcdn.net") || url.includes("fbsbx.com");
+          const response = await request(url, {
+            method: "GET",
+            headers,
+            ...usePool ? { dispatcher: getAgent() } : {},
+            signal: controller.signal
+          });
+          const body = await response.body.text();
+          const statusCode = response.statusCode;
+          const resHeaders = {};
+          for (const [key, value] of Object.entries(response.headers)) {
+            if (typeof value === "string") resHeaders[key] = value;
+            else if (Array.isArray(value)) resHeaders[key] = value.join(", ");
+          }
+          if (statusCode === 429) {
+            const err = new Error("Rate limited");
+            err.statusCode = 429;
+            throw err;
+          }
+          if (statusCode >= 500) {
+            const err = new Error(`Server error ${statusCode}`);
+            err.statusCode = statusCode;
+            throw err;
+          }
+          return { body, statusCode, headers: resHeaders };
+        } finally {
+          clearTimeout(timer);
+        }
+      },
+      { maxRetries: this.retries }
+    );
+  }
+  getInFlightCount() {
+    return inFlight.size;
+  }
+};
+
+// src/core/cache.ts
+init_esm_shims();
+import { LRUCache } from "lru-cache";
+var ResponseCache = class {
+  lru;
+  redis;
+  freshTtlMs;
+  staleTtlMs;
+  hits = 0;
+  misses = 0;
+  staleHits = 0;
+  constructor(options = {}) {
+    this.freshTtlMs = options.ttlMs ?? 3e5;
+    this.staleTtlMs = options.staleTtlMs ?? 864e5;
+    this.lru = new LRUCache({
+      max: options.maxSize ?? 500,
+      ttl: this.staleTtlMs
+    });
+    this.redis = options.redis;
+  }
+  wrap(value) {
+    const now = Date.now();
+    return {
+      payload: JSON.stringify(value),
+      freshUntil: now + this.freshTtlMs,
+      staleUntil: now + this.staleTtlMs
+    };
+  }
+  /** Instant in-memory fresh hit (sub-ms). */
+  getFreshSync(key) {
+    const entry = this.lru.get(key);
+    if (!entry || Date.now() > entry.freshUntil) return null;
+    this.hits++;
+    return JSON.parse(entry.payload);
+  }
+  /** Instant stale hit for stale-while-revalidate. */
+  getStaleSync(key) {
+    const entry = this.lru.get(key);
+    if (!entry || Date.now() > entry.staleUntil) return null;
+    if (Date.now() <= entry.freshUntil) return null;
+    this.staleHits++;
+    return JSON.parse(entry.payload);
+  }
+  async get(key) {
+    const fresh = this.getFreshSync(key);
+    if (fresh) return fresh;
+    if (this.redis) {
+      const remote = await this.redis.get(`ultra-igdl:${key}`);
+      if (remote) {
+        this.hits++;
+        const parsed = JSON.parse(remote);
+        this.lru.set(key, this.wrap(parsed));
+        return parsed;
+      }
+    }
+    this.misses++;
+    return null;
+  }
+  set(key, value) {
+    this.lru.set(key, this.wrap(value));
+    if (this.redis) {
+      void this.redis.set(`ultra-igdl:${key}`, JSON.stringify(value), this.staleTtlMs);
+    }
+  }
+  delete(key) {
+    this.lru.delete(key);
+    this.redis?.del?.(`ultra-igdl:${key}`);
+  }
+  clear() {
+    this.lru.clear();
+  }
+  getStats() {
+    const total = this.hits + this.misses + this.staleHits;
+    return {
+      size: this.lru.size,
+      maxSize: this.lru.max,
+      hits: this.hits,
+      misses: this.misses,
+      staleHits: this.staleHits,
+      hitRate: total > 0 ? (this.hits + this.staleHits) / total : 0
+    };
+  }
+};
+
+// src/core/extractor.ts
+init_esm_shims();
+
+// src/extractors/reel.ts
+init_esm_shims();
+
+// src/extractors/post.ts
+init_esm_shims();
+init_parser();
+async function extractPost(ctx) {
+  if (detectRateLimit(ctx.html)) {
+    throw Object.assign(new Error("Rate limited"), { code: 429 });
+  }
+  if (detectNotFound(ctx.html, 200)) {
+    return null;
+  }
+  return parseHtml(ctx.html, ctx.parsed.type);
+}
+
+// src/extractors/reel.ts
+async function extractReel(ctx) {
+  return extractPost(ctx);
+}
+
+// src/extractors/story.ts
+init_esm_shims();
+init_parser();
+
+// src/utils/media-quality.ts
+init_esm_shims();
+
+// src/utils/media-dimensions.ts
+init_esm_shims();
+init_parser();
+function maxOriginalDimensionsFromHtml(html) {
+  let bestArea = 0;
+  let width;
+  let height;
+  const patterns = [
+    /"original_width":\s*(\d+)\s*,\s*"original_height":\s*(\d+)/g,
+    /"original_width":(\d+),"original_height":(\d+)/g,
+    /original_width\\":(\d+),\\"original_height\\":(\d+)/g
+  ];
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(html)) !== null) {
+      const w = parseInt(m[1], 10);
+      const h = parseInt(m[2], 10);
+      const area2 = w * h;
+      if (area2 > bestArea) {
+        bestArea = area2;
+        width = w;
+        height = h;
+      }
+    }
+  }
+  return { width, height };
+}
+function scrapeImageCandidates(html) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (url, w, h) => {
+    const decoded = decodeEscapedUrl(url.replace(/\\u0026/g, "&").replace(/\\\//g, "/"));
+    if (!decoded.startsWith("http")) return;
+    const key = decoded.split("?")[0];
+    if (seen.has(key)) return;
+    seen.add(key);
+    candidates.push({ url: decoded, width: w, height: h });
+  };
+  const iv2 = /"width":\s*(\d+)\s*,\s*"height":\s*(\d+)[\s\S]*?"url":\s*"([^"]+)"/g;
+  let m;
+  while ((m = iv2.exec(html)) !== null) {
+    add(m[3], parseInt(m[1], 10), parseInt(m[2], 10));
+  }
+  const iv2t = /"url":\s*"([^"]+)"[\s\S]*?"width":\s*(\d+)\s*,\s*"height":\s*(\d+)/g;
+  while ((m = iv2t.exec(html)) !== null) {
+    add(m[1], parseInt(m[2], 10), parseInt(m[3], 10));
+  }
+  const resources = /"config_width":\s*(\d+)\s*,\s*"config_height":\s*(\d+)[^}]*"src":\s*"([^"]+)"/g;
+  while ((m = resources.exec(html)) !== null) {
+    add(m[3], parseInt(m[1], 10), parseInt(m[2], 10));
+  }
+  const displayUrl = /"display_url":\s*"([^"]+)"[\s\S]{0,400}?"original_width":\s*(\d+)\s*,\s*"original_height":\s*(\d+)/g;
+  while ((m = displayUrl.exec(html)) !== null) {
+    add(m[1], parseInt(m[2], 10), parseInt(m[3], 10));
+  }
+  return candidates;
+}
+function mediaAssetKey(url) {
+  const m = url.match(/\/(\d+)_(\d+)_/);
+  return m ? `${m[1]}_${m[2]}` : null;
+}
+function isLowResDeliveryUrl(url) {
+  return /_s640x640|_s\d{3}x\d{3}_|e\d+_s640x640/i.test(url);
+}
+function bestImageCandidateForMedia(html, mediaUrl) {
+  const candidates = scrapeImageCandidates(html);
+  if (!candidates.length) return null;
+  const key = mediaAssetKey(mediaUrl);
+  if (key) {
+    const matched = candidates.filter((c) => c.url.includes(key));
+    if (matched.length) return pickLargestCandidate(matched);
+  }
+  return pickLargestCandidate(candidates);
+}
+function pickLargestCandidate(candidates) {
+  const valid = candidates.filter((c) => isValidMediaUrl(c.url));
+  const pool = valid.length ? valid : candidates;
+  const sorted = [...pool].sort((a, b) => b.width * b.height - a.width * a.height);
+  const withoutLow = sorted.find((c) => !isLowResDeliveryUrl(c.url));
+  return withoutLow ?? sorted[0];
+}
+function scrapeAssetUrlsFromHtml(html, assetKey) {
+  const urls = [];
+  const patterns = [
+    new RegExp(`"(https?:[^"]*${assetKey}[^"]*)"`, "gi"),
+    new RegExp(`(https?:\\\\/\\\\/[^"\\\\]*${assetKey}[^"\\\\]*)`, "gi")
+  ];
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(html)) !== null) {
+      const decoded = decodeEscapedUrl(m[1]);
+      if (isValidMediaUrl(decoded)) urls.push(decoded);
+    }
+  }
+  return urls;
+}
+function enrichImageDimensions(media, html) {
+  if (media.type !== "image") return media;
+  const best = bestImageCandidateForMedia(html, media.url);
+  const fromOriginal = maxOriginalDimensionsFromHtml(html);
+  const fromStp = dimensionsFromImageUrl(media.url);
+  let width = media.width;
+  let height = media.height;
+  let url = media.url;
+  const apply = (w, h, candidateUrl) => {
+    if (!w || !h) return;
+    const area2 = w * h;
+    const cur = (width ?? 0) * (height ?? 0);
+    const urlArea = dimensionsFromImageUrl(url);
+    const curUrlArea = (urlArea.width ?? 0) * (urlArea.height ?? 0);
+    const betterDims = area2 > cur;
+    const betterUrl = candidateUrl && (!isLowResDeliveryUrl(candidateUrl) || isLowResDeliveryUrl(url) && area2 >= curUrlArea);
+    if (betterDims) {
+      width = w;
+      height = h;
+    }
+    if (betterUrl && (betterDims || area2 >= curUrlArea)) {
+      url = candidateUrl;
+    }
+  };
+  apply(fromOriginal.width, fromOriginal.height);
+  apply(fromStp.width, fromStp.height);
+  if (best) apply(best.width, best.height, best.url);
+  const assetKey = mediaAssetKey(media.url);
+  if (assetKey && isLowResDeliveryUrl(url)) {
+    const alternates = scrapeAssetUrlsFromHtml(html, assetKey);
+    const better = alternates.filter((u) => !isLowResDeliveryUrl(u)).map((u) => ({ url: u, ...dimensionsFromImageUrl(u) })).filter((c) => c.width && c.height).sort((a, b) => b.width * b.height - a.width * a.height)[0];
+    if (better) apply(better.width, better.height, better.url);
+  }
+  if ((!width || !height) && fromStp.width && fromStp.height) {
+    width = fromStp.width;
+    height = fromStp.height;
+  }
+  if (!isValidMediaUrl(url)) {
+    url = media.url;
+  }
+  return { ...media, url, width, height };
+}
+function applyPageHtmlToMedia(media, html) {
+  const images = media.filter((m) => m.type === "image");
+  if (images.length > 1) {
+    return media.map((m) => {
+      if (m.type !== "image") return m;
+      const dims = dimensionsFromImageUrl(m.url);
+      return {
+        ...m,
+        width: m.width ?? dims.width,
+        height: m.height ?? dims.height
+      };
+    });
+  }
+  return media.map((m) => m.type === "image" ? enrichImageDimensions(m, html) : m);
+}
+function mediaArea(m) {
+  return (m.width ?? 0) * (m.height ?? 0);
+}
+function imageNeedsDimensions(media) {
+  const img = media.find((m) => m.type === "image");
+  return Boolean(img && (!img.width || !img.height));
+}
+function imageNeedsHigherResolution(media) {
+  const img = media.find((m) => m.type === "image");
+  if (!img) return false;
+  if (!isLowResDeliveryUrl(img.url)) return false;
+  const area2 = (img.width ?? 0) * (img.height ?? 0);
+  if (area2 > 640 * 640) return true;
+  const fromStp = dimensionsFromImageUrl(img.url);
+  return (fromStp.width ?? 0) * (fromStp.height ?? 0) > 640 * 640;
+}
+function postNeedsEmbedFetch(media) {
+  return imageNeedsDimensions(media) || imageNeedsHigherResolution(media);
+}
+
+// src/utils/media-quality.ts
+function isValidMediaUrl(url) {
+  if (!isCdnMediaUrl(url)) return false;
+  if (/\.js(?:\?|$)/i.test(url) || /rsrc\.php/i.test(url)) return false;
+  if (/static\.cdninstagram\.com/i.test(url)) return false;
+  return true;
+}
+function filterValidMedia(media) {
+  return media.filter((m) => isValidMediaUrl(m.url));
+}
+function dimensionsFromImageUrl(url) {
+  const crop = url.match(/stp=c[\d.]+?\.(\d+)\.(\d+)a/i);
+  if (crop) {
+    return { width: parseInt(crop[1], 10), height: parseInt(crop[2], 10) };
+  }
+  const size = url.match(/_s(\d+)x(\d+)_/i);
+  if (size) {
+    return { width: parseInt(size[1], 10), height: parseInt(size[2], 10) };
+  }
+  return {};
+}
+function upgradeMediaItem(media, html) {
+  if (media.type !== "image") return media;
+  if (html) return enrichImageDimensions(media, html);
+  const dims = dimensionsFromImageUrl(media.url);
+  return {
+    ...media,
+    url: media.url,
+    width: media.width ?? dims.width,
+    height: media.height ?? dims.height
+  };
+}
+function isStoryProfileImage(url) {
+  return /\/t51\.2885-19\//.test(url) || /stp=dst-jpg_s\d+x\d+/.test(url) || /profile_pic/i.test(url);
+}
+function isCdnMediaUrl(url) {
+  return /cdninstagram\.com|fbcdn\.net|fbsbx\.com/i.test(url);
+}
+function isValidThumbnailUrl(url) {
+  if (!url) return false;
+  if (/\.js(?:\?|$)/i.test(url) || /rsrc\.php/i.test(url)) return false;
+  return isCdnMediaUrl(url);
+}
+
+// src/network/instagram-api.ts
+init_esm_shims();
+init_parser();
+init_caption();
+
+// src/utils/engagement-tags.ts
+init_esm_shims();
+function ogDescriptionHasPublicCounts(ogDescription) {
+  return /^\d[\d.KMB,\s]*(?:likes?|comments?|views?)/i.test(ogDescription.trim());
+}
+function scrapeEngagementFlagsFromHtml(html) {
+  let likesHidden = false;
+  let commentsHidden = false;
+  if (!html) return { likesHidden, commentsHidden };
+  if (/like_and_view_counts_disabled":\s*true/i.test(html) || /"hide_like_and_view_counts":\s*true/i.test(html)) {
+    likesHidden = true;
+  }
+  if (/comments_disabled":\s*true/i.test(html)) {
+    commentsHidden = true;
+  }
+  return { likesHidden, commentsHidden };
+}
+function engagementFromApiItem(item) {
+  const engagement = {};
+  if (typeof item.like_count === "number") engagement.likes = item.like_count;
+  if (typeof item.comment_count === "number") engagement.comments = item.comment_count;
+  if (typeof item.view_count === "number") engagement.views = item.view_count;
+  if (typeof item.play_count === "number" && engagement.views == null) {
+    engagement.views = item.play_count;
+  }
+  if (item.like_and_view_counts_disabled === true) {
+    engagement.likesHidden = true;
+  }
+  if (item.comments_disabled === true) {
+    engagement.commentsHidden = true;
+  }
+  const hasMetric = engagement.likes != null || engagement.comments != null || engagement.views != null;
+  const hasFlags = engagement.likesHidden || engagement.commentsHidden;
+  return hasMetric || hasFlags ? engagement : void 0;
+}
+function buildEngagementTags(parsedType, ogDescription, engagement, html) {
+  const tags = /* @__PURE__ */ new Set();
+  const countable = parsedType === "reel" || parsedType === "post" || parsedType === "tv";
+  if (engagement.likesHidden) tags.add("likes_hidden");
+  if (engagement.commentsHidden) tags.add("comments_hidden");
+  const fromHtml = scrapeEngagementFlagsFromHtml(html);
+  if (fromHtml.likesHidden) tags.add("likes_hidden");
+  if (fromHtml.commentsHidden) tags.add("comments_hidden");
+  if (!countable || !ogDescription?.trim()) {
+    return [...tags];
+  }
+  const publicCounts = ogDescriptionHasPublicCounts(ogDescription);
+  const captionOnlyOg = /\bon\s+[\w\s\d,.]+:\s*["']/i.test(ogDescription);
+  if (captionOnlyOg && !publicCounts) {
+    if (engagement.likes == null) tags.add("likes_hidden");
+    if (engagement.comments == null) tags.add("comments_hidden");
+  }
+  if (tags.has("likes_hidden") && tags.has("comments_hidden")) {
+    tags.add("engagement_hidden");
+  }
+  return [...tags];
+}
+
+// src/network/instagram-api.ts
+init_logger();
+var IG_APP_ID = "936619743392459";
+var API_HOSTS = ["https://www.instagram.com", "https://i.instagram.com"];
+function normalizeSessionId(sessionId) {
+  const trimmed = sessionId.trim();
+  try {
+    return decodeURIComponent(trimmed);
+  } catch {
+    return trimmed;
+  }
+}
+function buildSessionCookie(sessionId, cookies) {
+  if (cookies?.trim()) {
+    const map = /* @__PURE__ */ new Map();
+    for (const part of cookies.trim().split(";")) {
+      const [k, ...rest] = part.trim().split("=");
+      if (k) map.set(k.trim(), rest.join("=").trim());
+    }
+    if (map.has("sessionid")) {
+      map.set("sessionid", normalizeSessionId(map.get("sessionid")));
+    }
+    return [...map.entries()].map(([k, v]) => `${k}=${v}`).join("; ");
+  }
+  if (sessionId?.trim()) return `sessionid=${normalizeSessionId(sessionId)}`;
+  return void 0;
+}
+function mergeSetCookie(existing, setCookieHeader) {
+  const map = /* @__PURE__ */ new Map();
+  for (const part of existing.split(";")) {
+    const [k, ...rest] = part.trim().split("=");
+    if (k) map.set(k.trim(), rest.join("=").trim());
+  }
+  const headers = Array.isArray(setCookieHeader) ? setCookieHeader : setCookieHeader ? [setCookieHeader] : [];
+  for (const h of headers) {
+    const first = h.split(";")[0];
+    const eq = first.indexOf("=");
+    if (eq > 0) map.set(first.slice(0, eq).trim(), first.slice(eq + 1).trim());
+  }
+  return [...map.entries()].map(([k, v]) => `${k}=${v}`).join("; ");
+}
+function userIdFromCookie(sessionCookie) {
+  const id = sessionCookie.match(/ds_user_id=([^;]+)/)?.[1];
+  return id && /^\d+$/.test(id) ? id : null;
+}
+function sessionCookieReady(cookie) {
+  return cookie.includes("csrftoken=") && cookie.includes("ds_user_id=");
+}
+async function enrichSessionCookie(cookie) {
+  if (sessionCookieReady(cookie)) return cookie;
+  const res = await request("https://www.instagram.com/", {
+    headers: {
+      ...buildInstagramPageHeaders(),
+      Cookie: cookie
+    }
+  });
+  await res.body.text();
+  return mergeSetCookie(cookie, res.headers["set-cookie"]);
+}
+function parseCsrfFromCookie(cookie) {
+  return cookie.match(/csrftoken=([^;]+)/)?.[1] ?? "";
+}
+function mediaFromStoryItem(item) {
+  const media = [];
+  const isVideo = item.media_type === 2 || item.is_video === true;
+  if (isVideo && Array.isArray(item.video_versions)) {
+    const versions = item.video_versions;
+    const best = versions.reduce(
+      (a, b) => (b.width ?? 0) > (a.width ?? 0) ? b : a
+    );
+    if (typeof best.url === "string") {
+      media.push({
+        type: "video",
+        url: decodeEscapedUrl(best.url),
+        width: best.width,
+        height: best.height,
+        duration: item.video_duration
+      });
+    }
+  }
+  const candidates = item.image_versions2?.candidates;
+  if (candidates?.length) {
+    const best = candidates.reduce(
+      (a, b) => (b.width ?? 0) > (a.width ?? 0) ? b : a
+    );
+    if (typeof best.url === "string") {
+      const image = {
+        type: "image",
+        url: decodeEscapedUrl(best.url),
+        width: best.width ?? item.original_width,
+        height: best.height ?? item.original_height
+      };
+      if (!media.length || !isVideo) media.push(image);
+      else if (media[0] && !media[0].thumbnail) media[0].thumbnail = image.url;
+    }
+  }
+  return media;
+}
+function mediaFromApiItem(item) {
+  const carousel = item.carousel_media;
+  if (Array.isArray(carousel) && carousel.length > 0) {
+    const media = [];
+    for (const slide of carousel) {
+      if (slide && typeof slide === "object") {
+        media.push(...mediaFromStoryItem(slide));
+      }
+    }
+    return media;
+  }
+  return mediaFromStoryItem(item);
+}
+var API_TIMEOUT_MS = 6e3;
+async function igApiGet(path2, sessionCookie, referer, host = API_HOSTS[0], timeoutMs = API_TIMEOUT_MS) {
+  const csrf = parseCsrfFromCookie(sessionCookie);
+  const headers = {
+    ...buildApiHeaders(),
+    Cookie: sessionCookie,
+    Referer: referer,
+    "X-CSRFToken": csrf,
+    "X-IG-App-ID": IG_APP_ID
+  };
+  const url = path2.startsWith("http") ? path2 : `${host}${path2}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await request(url, {
+      method: "GET",
+      headers,
+      signal: controller.signal
+    });
+    const body = await response.body.text();
+    return { statusCode: response.statusCode, body };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchStoryPageWithSession(url, sessionCookie) {
+  const response = await request(url, {
+    headers: {
+      ...buildInstagramPageHeaders(),
+      Cookie: sessionCookie
+    }
+  });
+  const body = await response.body.text();
+  return { statusCode: response.statusCode, body };
+}
+function extractStoryMediaFromHtml(html, storyId) {
+  const media = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (item) => {
+    if (isStoryProfileImage(item.url)) return;
+    const key = item.url.split("?")[0];
+    if (seen.has(key)) return;
+    seen.add(key);
+    media.push(item);
+  };
+  if (storyId) {
+    let pos = 0;
+    while ((pos = html.indexOf(storyId, pos)) !== -1) {
+      const chunk = html.slice(Math.max(0, pos - 12e3), pos + 16e3);
+      collectFromChunk(chunk, add);
+      pos += storyId.length;
+    }
+  }
+  collectFromChunk(html, add);
+  return media;
+}
+function collectFromChunk(chunk, add) {
+  const patterns = [
+    /"video_versions":\s*\[[^\]]*?"url":\s*"([^"]+)"/g,
+    /video_url\\":\\"([^"]+)/g,
+    /"playback_url":"(https?:[^"]+)"/g,
+    /"url":"(https?:\\\/\\\/[^"]*?fbcdn[^"]+)"/g,
+    /"url":"(https?:\\\/\\\/[^"]*?cdninstagram[^"]+)"/g
+  ];
+  for (const pattern of patterns) {
+    let m;
+    while ((m = pattern.exec(chunk)) !== null) {
+      let url = decodeEscapedUrl(m[1]);
+      if (!url.startsWith("http")) url = `https://${url.replace(/^\/+/, "")}`;
+      if (url.includes(".mp4") || url.includes("video")) {
+        add({ type: "video", url });
+      } else if (url.includes("cdninstagram") || url.includes("fbcdn")) {
+        add({ type: "image", url });
+      }
+    }
+  }
+}
+async function fetchUserId(username, sessionCookie, referer) {
+  const fromCookie = userIdFromCookie(sessionCookie);
+  if (fromCookie) return fromCookie;
+  for (const host of API_HOSTS) {
+    const { statusCode, body } = await igApiGet(
+      `/api/v1/users/web_profile_info/?username=${encodeURIComponent(username)}`,
+      sessionCookie,
+      referer,
+      host
+    );
+    if (statusCode === 429) break;
+    if (statusCode !== 200) continue;
+    try {
+      const data = JSON.parse(body);
+      const user = data.data?.user;
+      const id = user?.id ?? user?.pk;
+      if (id != null) return String(id);
+    } catch {
+      const m = body.match(/"id":"(\d+)"/);
+      if (m) return m[1];
+    }
+  }
+  return null;
+}
+function storyItemMatches(item, storyPk) {
+  const ids = [item.pk, item.id, item.media_id, item.story_media_id, item.fbid, item.code].map(
+    (v) => v != null ? String(v) : ""
+  );
+  return ids.some(
+    (id) => id === storyPk || id.startsWith(`${storyPk}_`) || storyPk.startsWith(`${id}_`) || id.includes(storyPk)
+  );
+}
+function parseMediaInfoBody(body) {
+  try {
+    const payload = JSON.parse(body);
+    const items = payload.items;
+    const item = items?.[0] ?? payload;
+    if (!item || typeof item !== "object") return null;
+    const media = mediaFromApiItem(item);
+    if (!media.length) return null;
+    const user = item.user;
+    return {
+      media,
+      caption: extractCaptionFromApiItem(item),
+      username: typeof user?.username === "string" ? user.username : "",
+      engagement: engagementFromApiItem(item)
+    };
+  } catch {
+    return null;
+  }
+}
+async function fetchMediaInfoOnce(id, sessionCookie, referer, host, timeoutMs) {
+  const { statusCode, body } = await igApiGet(
+    `/api/v1/media/${id}/info/?media_id=${id}`,
+    sessionCookie,
+    referer,
+    host,
+    timeoutMs ?? API_TIMEOUT_MS
+  );
+  if (statusCode !== 200) {
+    logger.debug(`media info ${statusCode} ${host} id=${id}`);
+    return null;
+  }
+  const parsed = parseMediaInfoBody(body);
+  return parsed?.media.length ? parsed : null;
+}
+async function fetchMediaInfoByPk(mediaPk, sessionCookie, referer, ownerUserId, timeoutMs) {
+  const ids = ownerUserId ? [mediaPk, `${mediaPk}_${ownerUserId}`] : [mediaPk];
+  const perAttempt = timeoutMs ?? API_TIMEOUT_MS;
+  const attempts = [];
+  for (const host of API_HOSTS) {
+    for (const id of ids) {
+      attempts.push(
+        fetchMediaInfoOnce(id, sessionCookie, referer, host, perAttempt).then((r) => {
+          if (!r?.media.length) throw new Error("miss");
+          return r;
+        })
+      );
+    }
+  }
+  try {
+    return await Promise.any(attempts);
+  } catch {
+    return null;
+  }
+}
+async function fetchUserStoryFeed(userId, sessionCookie, referer, storyPk) {
+  for (const host of API_HOSTS) {
+    const { statusCode, body } = await igApiGet(
+      `/api/v1/feed/user/${userId}/story/`,
+      sessionCookie,
+      referer,
+      host
+    );
+    if (statusCode !== 200) {
+      logger.debug(`user story feed ${statusCode} ${host}`);
+      continue;
+    }
+    try {
+      const payload = JSON.parse(body);
+      const reel = payload.reel;
+      const items = reel?.items ?? payload.items;
+      if (!items?.length) continue;
+      const item = (storyPk ? items.find((i) => storyItemMatches(i, storyPk)) : void 0) ?? items[0];
+      const media = mediaFromStoryItem(item);
+      if (!media.length) continue;
+      return { media, caption: "", username: "" };
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function fetchReelsMedia(userId, sessionCookie, referer, storyPk) {
+  for (const host of API_HOSTS) {
+    const { statusCode, body } = await igApiGet(
+      `/api/v1/feed/reels_media/?reel_ids=${userId}`,
+      sessionCookie,
+      referer,
+      host
+    );
+    if (statusCode !== 200) {
+      logger.debug(`reels_media ${statusCode} ${host}`);
+      continue;
+    }
+    try {
+      const payload = JSON.parse(body);
+      const reels = payload.reels;
+      const reel = reels?.[userId] ?? Object.values(reels ?? {})[0];
+      const items = reel?.items;
+      if (!items?.length) continue;
+      const item = (storyPk ? items.find((i) => storyItemMatches(i, storyPk)) : void 0) ?? items[0];
+      const media = mediaFromStoryItem(item);
+      if (!media.length) continue;
+      return { media, caption: "", username: "" };
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function storyMediaFromPageHtml(html, storyPk) {
+  const fromHtml = extractStoryMediaFromHtml(html, storyPk);
+  const videos = fromHtml.filter((m) => m.type === "video" && isCdnMediaUrl(m.url));
+  if (videos.length) {
+    return { media: videos, caption: "", username: "" };
+  }
+  const parsedHtml = parseHtml(html, "story");
+  const ogMedia = parsedHtml?.media.filter(
+    (m) => !isStoryProfileImage(m.url) && (m.type === "video" ? isCdnMediaUrl(m.url) : true)
+  ) ?? [];
+  if (ogMedia.length) {
+    return { media: ogMedia, caption: "", username: "" };
+  }
+  return null;
+}
+async function fetchStoryViaSession(parsed, sessionCookie, existingPageHtml) {
+  if (!parsed.username) return null;
+  const referer = parsed.normalized;
+  const storyPk = parsed.storyId;
+  const ownerUserId = userIdFromCookie(sessionCookie);
+  if (storyPk) {
+    const direct = await fetchMediaInfoByPk(
+      storyPk,
+      sessionCookie,
+      referer,
+      ownerUserId ?? void 0
+    );
+    if (direct?.media.length) {
+      return { ...direct, username: parsed.username };
+    }
+  }
+  if (existingPageHtml) {
+    const fromPage = storyMediaFromPageHtml(existingPageHtml, storyPk);
+    if (fromPage?.media.length) {
+      return { ...fromPage, username: parsed.username };
+    }
+  }
+  if (!existingPageHtml) {
+    const authPage = await fetchStoryPageWithSession(referer, sessionCookie);
+    if (authPage.statusCode === 200) {
+      const fromPage = storyMediaFromPageHtml(authPage.body, storyPk);
+      if (fromPage?.media.length) {
+        return { ...fromPage, username: parsed.username };
+      }
+    }
+  }
+  const userId = ownerUserId ?? await fetchUserId(parsed.username, sessionCookie, referer);
+  if (!userId) return null;
+  const feed = await fetchUserStoryFeed(userId, sessionCookie, referer, storyPk);
+  if (feed?.media.length) {
+    return { ...feed, username: parsed.username };
+  }
+  const reels = await fetchReelsMedia(userId, sessionCookie, referer, storyPk);
+  if (reels?.media.length) {
+    return { ...reels, username: parsed.username };
+  }
+  if (storyPk) {
+    const retry = await fetchMediaInfoByPk(storyPk, sessionCookie, referer, userId);
+    if (retry?.media.length) {
+      return { ...retry, username: parsed.username };
+    }
+  }
+  return null;
+}
+
+// src/extractors/story.ts
+async function extractStory(ctx) {
+  if (detectRateLimit(ctx.html)) {
+    throw Object.assign(new Error("Rate limited"), { code: 429 });
+  }
+  if (detectNotFound(ctx.html, 200)) {
+    return null;
+  }
+  const nearId = extractStoryMediaFromHtml(ctx.html, ctx.parsed.storyId);
+  const parsed = parseHtml(ctx.html, "story");
+  const media = [
+    ...nearId,
+    ...parsed?.media.filter((m) => !isStoryProfileImage(m.url)) ?? []
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const unique = media.filter((m) => {
+    const k = m.url.split("?")[0];
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+  if (!unique.length && parsed) {
+    return {
+      media: [],
+      caption: "",
+      username: ctx.parsed.username ?? ""
+    };
+  }
+  if (!unique.length) return null;
+  return {
+    media: unique,
+    caption: parsed?.caption ?? "",
+    username: ctx.parsed.username ?? parsed?.username ?? ""
+  };
+}
+
+// src/extractors/highlight.ts
+init_esm_shims();
+init_parser();
+function parseMediaBlock(chunk) {
+  const isVideo = /"media_type":\s*2/.test(chunk) || /"is_video":\s*true/.test(chunk);
+  if (isVideo) {
+    const videoRe = /"video_versions":\s*\[[^\]]*?"width":\s*(\d+)[^}]*"height":\s*(\d+)[^}]*"url":\s*"([^"]+)"/;
+    const vm = chunk.match(videoRe);
+    if (vm) {
+      return {
+        type: "video",
+        url: decodeEscapedUrl(vm[3].replace(/\\u0026/g, "&").replace(/\\\//g, "/")),
+        width: parseInt(vm[1], 10),
+        height: parseInt(vm[2], 10)
+      };
+    }
+    const urlOnly = /"video_versions":\[[^\]]*?"url":"([^"]+)"/.exec(chunk);
+    if (urlOnly) {
+      return {
+        type: "video",
+        url: decodeEscapedUrl(urlOnly[1].replace(/\\u0026/g, "&").replace(/\\\//g, "/"))
+      };
+    }
+  }
+  const imgRe = /"image_versions2":\s*\{\s*"candidates":\s*\[[^\]]*?"width":\s*(\d+)\s*,\s*"height":\s*(\d+)[^}]*"url":\s*"([^"]+)"/;
+  const im = chunk.match(imgRe);
+  if (im) {
+    return {
+      type: "image",
+      url: decodeEscapedUrl(im[3].replace(/\\u0026/g, "&").replace(/\\\//g, "/")),
+      width: parseInt(im[1], 10),
+      height: parseInt(im[2], 10)
+    };
+  }
+  return null;
+}
+function extractNearMediaId(html, storyMediaId) {
+  const pk = storyMediaId?.split("_")[0];
+  if (!pk) return [];
+  const media = [];
+  let pos = 0;
+  while ((pos = html.indexOf(pk, pos)) !== -1 && media.length < 8) {
+    const chunk = html.slice(Math.max(0, pos - 14e3), pos + 18e3);
+    const item = parseMediaBlock(chunk);
+    if (item && !media.some((m) => m.url === item.url)) {
+      media.push(item);
+    }
+    pos += pk.length;
+  }
+  return media;
+}
+function dedupeMediaList(media) {
+  const seen = /* @__PURE__ */ new Set();
+  return media.filter((m) => {
+    const k = m.url.split("?")[0];
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+async function extractHighlight(ctx) {
+  if (detectRateLimit(ctx.html)) {
+    throw Object.assign(new Error("Rate limited"), { code: 429 });
+  }
+  if (detectNotFound(ctx.html, 200)) {
+    return null;
+  }
+  const parsed = parseHtml(ctx.html, "highlight");
+  const allMedia = [];
+  allMedia.push(...extractNearMediaId(ctx.html, ctx.parsed.storyMediaId));
+  if (parsed?.media.length) {
+    allMedia.push(...parsed.media);
+  }
+  const itemRegex = /"media_type":\s*(\d+)[\s\S]{0,4000}?(?="media_type":|$)/g;
+  let match;
+  while ((match = itemRegex.exec(ctx.html)) !== null) {
+    const block = match[0];
+    const item = parseMediaBlock(block);
+    if (item && !allMedia.some((m) => m.url === item.url)) {
+      allMedia.push(item);
+    }
+  }
+  const unique = dedupeMediaList(allMedia).map(
+    (m) => m.type === "image" ? enrichImageDimensions(m, ctx.html) : m
+  );
+  if (!unique.length) return parsed;
+  return {
+    media: unique,
+    caption: parsed?.caption ?? "",
+    username: ctx.parsed.username ?? parsed?.username ?? ""
+  };
+}
+
+// src/core/extractor.ts
+async function runExtractor(ctx) {
+  const { parsed } = ctx;
+  switch (parsed.type) {
+    case "reel":
+    case "tv":
+      return extractReel(ctx);
+    case "post":
+      return extractPost(ctx);
+    case "story":
+      return extractStory(ctx);
+    case "highlight":
+      return extractHighlight(ctx);
+    default:
+      return extractPost(ctx);
+  }
+}
+function resolveFetchUrl(parsed) {
+  if (parsed.type === "story" && parsed.username && !parsed.storyId) {
+    return `https://www.instagram.com/stories/${parsed.username}/`;
+  }
+  return parsed.normalized;
+}
+function resolveEmbedUrl(parsed) {
+  if (!parsed.shortcode) return null;
+  if (parsed.type === "reel") {
+    return `https://www.instagram.com/reel/${parsed.shortcode}/embed/`;
+  }
+  if (parsed.type === "post") {
+    return `https://www.instagram.com/p/${parsed.shortcode}/embed/`;
+  }
+  if (parsed.type === "tv") {
+    return `https://www.instagram.com/tv/${parsed.shortcode}/embed/`;
+  }
+  return null;
+}
+function resolveStoryEmbedUrl(parsed) {
+  if (parsed.type !== "story" || !parsed.username || !parsed.storyId) return null;
+  return `https://www.instagram.com/stories/${parsed.username}/${parsed.storyId}/embed/`;
+}
+
+// src/core/downloader.ts
+init_parser();
+
+// src/core/normalize.ts
+init_esm_shims();
+import * as cheerio2 from "cheerio";
+init_engagement();
+init_caption();
+init_parser();
+
+// src/utils/post-carousel.ts
+init_esm_shims();
+init_parser();
+function imageQualityScore(item) {
+  const area2 = mediaArea(item);
+  if (area2 > 0) return area2;
+  return item.width ?? 0;
+}
+function encodeTagFromUrl(url) {
+  const raw = url.match(/[?&]efg=([^&]+)/i)?.[1];
+  if (!raw) return null;
+  try {
+    const b64 = decodeURIComponent(raw);
+    const json = JSON.parse(Buffer.from(b64, "base64").toString("utf8"));
+    return json.encode_tag ?? json.vencode_tag ?? json.efg_tag ?? null;
+  } catch {
+    return null;
+  }
+}
+function isCarouselAuxiliaryImage(url) {
+  if (/CAROUSEL_BEST_IMAGE|best_image_urlgen|cover_photo/i.test(url)) return true;
+  const tag = encodeTagFromUrl(url);
+  if (tag && /BEST_IMAGE|COVER|THUMBNAIL/i.test(tag)) return true;
+  return false;
+}
+function stripCarouselAuxiliaryImages(media) {
+  return media.filter((m) => m.type !== "image" || !isCarouselAuxiliaryImage(m.url));
+}
+function slideKeyFromMediaUrl(url) {
+  const cacheKey = url.match(/ig_cache_key=([^&]+)/i)?.[1];
+  if (cacheKey) {
+    try {
+      return `ck:${decodeURIComponent(cacheKey)}`;
+    } catch {
+      return `ck:${cacheKey}`;
+    }
+  }
+  const base = (url.split("?")[0] ?? url).replace(/\\/g, "");
+  const fileId = base.match(/\/(\d{8,12})_(\d{10,})_\d+_n\./i);
+  if (fileId) return `file:${fileId[1]}_${fileId[2]}`;
+  const idMatch = base.match(/\/(\d{11,})(?:_\d+)?[_/]/);
+  if (idMatch) return `id:${idMatch[1]}`;
+  return base.replace(/_s\d+x\d+/gi, "").replace(/p\d+x\d+/gi, "");
+}
+function dedupePostSlides(media) {
+  if (media.length <= 1) return media;
+  const bestByKey = /* @__PURE__ */ new Map();
+  for (const item of media) {
+    if (item.type !== "image") continue;
+    const key = slideKeyFromMediaUrl(item.url);
+    const prev = bestByKey.get(key);
+    if (!prev || imageQualityScore(item) > imageQualityScore(prev)) bestByKey.set(key, item);
+  }
+  const out = [];
+  const usedImageKeys = /* @__PURE__ */ new Set();
+  for (const item of media) {
+    if (item.type === "video") {
+      out.push(item);
+      continue;
+    }
+    const key = slideKeyFromMediaUrl(item.url);
+    if (usedImageKeys.has(key)) continue;
+    usedImageKeys.add(key);
+    out.push(bestByKey.get(key) ?? item);
+  }
+  return out.length ? out : media;
+}
+function pickPostMedia(media, pageHtml = "") {
+  const filtered = stripCarouselAuxiliaryImages(media);
+  const imageCount = filtered.filter((m) => m.type === "image").length;
+  const upgraded = filtered.map((m) => {
+    if (m.type !== "image") return m;
+    return imageCount > 1 ? upgradeMediaItem(m) : upgradeMediaItem(m, pageHtml);
+  });
+  const slides = dedupePostSlides(upgraded);
+  if (slides.length <= 1) {
+    const only = slides[0];
+    if (!only) return [];
+    if (only.type === "video") return [only];
+    return [pickBestImage(upgraded) ?? only];
+  }
+  return slides;
+}
+
+// src/core/normalize.ts
+function pickBestMedia(media, contentType, pageHtml = "") {
+  const videos = media.filter((m) => m.type === "video");
+  const images = media.filter((m) => m.type === "image");
+  const preferVideo = contentType === "highlight" || contentType === "story";
+  const thumbUrl = (video, fallback) => {
+    if (isValidThumbnailUrl(video.thumbnail)) return video.thumbnail;
+    if (fallback) {
+      const upgraded = upgradeMediaItem(fallback, pageHtml).url;
+      return isValidThumbnailUrl(upgraded) ? upgraded : void 0;
+    }
+    return void 0;
+  };
+  const isReelOrTv = contentType === "reel" || contentType === "tv";
+  const bestVideo = pickBestVideo(videos);
+  if (bestVideo && (preferVideo || isReelOrTv)) {
+    const thumb = pickBestImage(images);
+    return [{ ...bestVideo, thumbnail: thumbUrl(bestVideo, thumb) }];
+  }
+  if (isReelOrTv) {
+    return bestVideo ? [bestVideo] : [];
+  }
+  if (contentType === "post") {
+    if (!images.length) return bestVideo ? [bestVideo] : [];
+    return pickPostMedia(media, pageHtml);
+  }
+  if (!images.length) return bestVideo ? [bestVideo] : [];
+  const enriched = images.map((m) => upgradeMediaItem(m, pageHtml));
+  const sorted = [...enriched].sort((a, b) => mediaArea(b) - mediaArea(a));
+  const bestImage = sorted[0] ?? pickBestImage(enriched);
+  return bestImage ? [bestImage] : [];
+}
+function extractPageMeta(html) {
+  if (!html) return {};
+  const $ = cheerio2.load(html);
+  const ogDescription = decodeHtmlEntities(
+    $('meta[property="og:description"]').attr("content") ?? ""
+  );
+  const ogTitle = decodeHtmlEntities($('meta[property="og:title"]').attr("content") ?? "");
+  return { ogDescription, ogTitle };
+}
+function normalizeExtraction(data, parsed, pageMeta = {}, pageHtml = "") {
+  if (!data) return null;
+  data = { ...data, media: filterValidMedia(data.media) };
+  if (!data.media.length && !data.isPrivate) return null;
+  const html = pageMeta.html ?? pageHtml;
+  const scrapedCaption = scrapeCaptionFromHtml(html);
+  let ogCaption = "";
+  let username = data.username;
+  let engagement = data.engagement ?? {};
+  if (pageMeta.ogDescription) {
+    const parsedDesc = parseInstagramDescription(pageMeta.ogDescription);
+    ogCaption = parsedDesc.caption;
+    if (parsedDesc.username) username = parsedDesc.username;
+    engagement = { ...engagement, ...parsedDesc.engagement };
+  }
+  let caption = resolveCaptionForContent(parsed.type, {
+    embed: pageMeta.embedCaption,
+    scraped: scrapedCaption,
+    extracted: data.caption,
+    og: ogCaption
+  });
+  if (pageMeta.ogTitle) {
+    const fromTitle = parseInstagramTitle(pageMeta.ogTitle);
+    if (fromTitle.username && !username) {
+      username = fromTitle.username;
+    }
+    if (fromTitle.caption) {
+      caption = parsed.type === "highlight" ? normalizeCaptionText(fromTitle.caption) || caption : resolveCaptionForContent(parsed.type, {
+        embed: pageMeta.embedCaption,
+        scraped: scrapedCaption,
+        extracted: caption,
+        og: fromTitle.caption
+      });
+    }
+  }
+  if (parsed.type === "story") {
+    if (parsed.username) username = parsed.username;
+    if (/^\d[\d.KMB,\s]*(?:likes?|comments?|views?)/i.test(caption)) {
+      const parsedDesc = parseInstagramDescription(caption);
+      caption = parsedDesc.caption;
+      engagement = { ...engagement, ...parsedDesc.engagement };
+    }
+    data.media = data.media.filter((m) => !isStoryProfileImage(m.url));
+  }
+  if (parsed.username && (parsed.type === "story" || parsed.type === "highlight")) {
+    username = parsed.username;
+  }
+  const skipHtmlEnrich = !html && (parsed.type === "story" || parsed.type === "highlight");
+  const enrichedMedia = (skipHtmlEnrich ? data.media : applyPageHtmlToMedia(data.media, html)).map(
+    (m) => {
+      if (m.type !== "image" || m.width && m.height) return m;
+      const dims = dimensionsFromImageUrl(m.url);
+      if (!dims.width || !dims.height) return m;
+      return { ...m, width: dims.width, height: dims.height };
+    }
+  );
+  const media = pickBestMedia(enrichedMedia, parsed.type, html);
+  const tags = [
+    .../* @__PURE__ */ new Set([
+      ...data.tags ?? [],
+      ...buildEngagementTags(parsed.type, pageMeta.ogDescription, engagement, html)
+    ])
+  ];
+  if (tags.includes("likes_hidden")) engagement.likesHidden = true;
+  if (tags.includes("comments_hidden")) engagement.commentsHidden = true;
+  const hasEngagementMetrics = engagement.likes != null || engagement.comments != null || engagement.views != null || engagement.shares != null || Boolean(engagement.raw);
+  const hasEngagement = hasEngagementMetrics || engagement.likesHidden || engagement.commentsHidden;
+  return {
+    ...data,
+    media,
+    caption: parsed.type === "post" ? normalizePostCaptionText(caption) : normalizeCaptionText(caption),
+    username: username.replace(/^@/, "").trim(),
+    engagement: hasEngagement ? engagement : void 0,
+    tags: tags.length ? tags : void 0
+  };
+}
+
+// src/network/post-media.ts
+init_esm_shims();
+var REDIRECT_TIMEOUT_MS = 6e3;
+function dimensionsFromRedirectUrl(url) {
+  const p = url.match(/p(\d+)x(\d+)/i);
+  if (p) {
+    return { width: parseInt(p[1], 10), height: parseInt(p[2], 10) };
+  }
+  return dimensionsFromImageUrl(url);
+}
+async function fetchPostLargeImageUrl(shortcode, timeoutMs = REDIRECT_TIMEOUT_MS) {
+  const pageUrl = `https://www.instagram.com/p/${shortcode}/media/?size=l`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await request(pageUrl, {
+      method: "GET",
+      headers: buildInstagramPageHeaders(),
+      signal: controller.signal,
+      // undici supports this; @types omit maxRedirections on RequestOptions
+      maxRedirections: 0
+    });
+    await response.body.text();
+    if (response.statusCode !== 301 && response.statusCode !== 302) return null;
+    const raw = response.headers.location;
+    const target = (Array.isArray(raw) ? raw[0] : raw)?.trim();
+    if (!target || !isValidMediaUrl(target) || isLowResDeliveryUrl(target) || !/\.(jpe?g|webp|png)/i.test(target.split("?")[0] ?? "")) {
+      return null;
+    }
+    return { url: target, ...dimensionsFromRedirectUrl(target) };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function applyLargePostImage(media, large) {
+  if (!isValidMediaUrl(large.url)) return media;
+  const multiImage = media.filter((m) => m.type === "image").length > 1;
+  let firstImageUpgraded = false;
+  return media.map((item) => {
+    if (item.type !== "image") return item;
+    if (multiImage && firstImageUpgraded) return item;
+    const fromUrl = dimensionsFromImageUrl(item.url);
+    const width = Math.max(item.width ?? 0, large.width ?? 0, fromUrl.width ?? 0) || item.width;
+    const height = Math.max(item.height ?? 0, large.height ?? 0, fromUrl.height ?? 0) || item.height;
+    firstImageUpgraded = true;
+    return { ...item, url: large.url, width, height };
+  });
+}
+
+// src/network/embed-caption.ts
+init_esm_shims();
+init_caption_normalize();
+import * as cheerio3 from "cheerio";
+function captionedEmbedUrl(parsed) {
+  if (!parsed.shortcode) return null;
+  const segment = parsed.type === "reel" ? "reel" : parsed.type === "tv" ? "tv" : "p";
+  return `https://www.instagram.com/${segment}/${parsed.shortcode}/embed/captioned/`;
+}
+function parseCaptionFromCaptionedEmbed(html, contentType = "reel") {
+  const $ = cheerio3.load(html);
+  const block = $(".Caption").first().text().trim();
+  if (!block) return "";
+  const user = $(".CaptionUsername").first().text().trim();
+  let caption = block;
+  if (user && caption.startsWith(user)) {
+    caption = caption.slice(user.length);
+  }
+  caption = caption.replace(/View all [\d,.]+[KMB]?\s+comments?.*$/i, "").trim();
+  if (contentType === "post") {
+    caption = caption.replace(/\n{3,}/g, "\n\n").trim();
+  } else {
+    caption = caption.replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
+  }
+  return normalizeCaptionText(caption);
+}
+function contentTypesWithEmbedCaption(type) {
+  return type === "reel" || type === "post" || type === "tv";
+}
+
+// src/utils/media-id.ts
+init_esm_shims();
+function extractMediaPkFromHtml(html) {
+  if (!html) return null;
+  const cacheKey = html.match(/ig_cache_key=([A-Za-z0-9%_+=]+)/i)?.[1];
+  if (cacheKey) {
+    try {
+      const decoded = Buffer.from(
+        decodeURIComponent(cacheKey.replace(/ /g, "+")),
+        "base64"
+      ).toString("utf8");
+      if (/^\d{10,}$/.test(decoded)) return decoded;
+    } catch {
+    }
+  }
+  const patterns = [
+    /data-media-id="(\d+)"/,
+    /data-media-id\\":\\"(\d+)\\"/,
+    /"media_id":"(\d+)"/,
+    /"pk":"(\d+)"/,
+    /"pk":"(\d+)"[^}]{0,120}"media_type":\s*2/
+  ];
+  for (const re of patterns) {
+    const m = html.match(re);
+    if (m?.[1]) return m[1];
+  }
+  return null;
+}
+
+// src/utils/post-media-pk.ts
+init_esm_shims();
+
+// src/utils/shortcode.ts
+init_esm_shims();
+var SHORTCODE_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function shortcodeToMediaPk(shortcode) {
+  if (!shortcode?.trim()) return null;
+  try {
+    let id = 0n;
+    for (const char of shortcode.trim()) {
+      const idx = SHORTCODE_ALPHABET.indexOf(char);
+      if (idx < 0) return null;
+      id = id * 64n + BigInt(idx);
+    }
+    return id > 0n ? id.toString() : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/post-media-pk.ts
+function postMediaPkCandidates(shortcode, html = "", media = []) {
+  const seen = /* @__PURE__ */ new Set();
+  const add = (pk) => {
+    if (pk && !seen.has(pk)) {
+      seen.add(pk);
+      return pk;
+    }
+    return null;
+  };
+  const out = [];
+  const fromShortcode = add(shortcodeToMediaPk(shortcode));
+  if (fromShortcode) {
+    out.push(fromShortcode);
+    return out;
+  }
+  const fromHtml = add(extractMediaPkFromHtml(html));
+  if (fromHtml) out.push(fromHtml);
+  for (const item of media) {
+    const fromUrl = add(extractMediaPkFromHtml(item.url));
+    if (fromUrl) out.push(fromUrl);
+  }
+  return out;
+}
+
+// src/utils/post-carousel-detect.ts
+init_esm_shims();
+function htmlIndicatesCarouselPost(html) {
+  if (!html) return false;
+  if (/edge_sidecar_to_children/.test(html)) return true;
+  if (/"carousel_media"\s*:/.test(html)) return true;
+  if (/carousel_media_count/.test(html)) return true;
+  if (/GraphSidecar/.test(html)) return true;
+  if (/CAROUSEL_ITEM/.test(html)) return true;
+  if (/media_type["\s]*:["\s]*8\b/.test(html)) return true;
+  if (/product_type["\s]*:["\s]*carousel/.test(html)) return true;
+  return false;
+}
+function buildPostContentTags(parsedType, mediaCount, html, hasSession) {
+  if (parsedType !== "post") return [];
+  if (mediaCount > 1) return ["carousel"];
+  if (!htmlIndicatesCarouselPost(html)) return [];
+  const tags = ["partial_carousel"];
+  if (!hasSession) tags.push("session_recommended");
+  return tags;
+}
+function mergeResultTags(existing, content) {
+  const merged = [.../* @__PURE__ */ new Set([...existing ?? [], ...content])];
+  return merged.length ? merged : void 0;
+}
+
+// src/utils/urls.ts
+init_esm_shims();
+var IG_HOST = /^(?:www\.)?instagram\.com$/i;
+function decodeShareSlug(slug) {
+  try {
+    const decoded = Buffer.from(slug, "base64").toString("utf8");
+    const match = decoded.match(/^highlight:(\d+)$/);
+    if (match) return { type: "highlight", id: match[1] };
+  } catch {
+    return null;
+  }
+  return null;
+}
+function buildNormalizedPath(pathname) {
+  let path2 = pathname.replace(/\/+$/, "");
+  if (!path2.endsWith("/")) path2 += "/";
+  return `https://www.instagram.com${path2}`;
+}
+function normalizeInstagramUrl(input) {
+  return parseInstagramUrl(input).normalized;
+}
+function parseInstagramUrl(input) {
+  let raw = input.trim();
+  if (!/^https?:\/\//i.test(raw)) {
+    const pathOnly = !raw.includes("instagram.com");
+    raw = pathOnly ? `https://www.instagram.com/${raw.replace(/^\//, "")}` : `https://${raw.replace(/^\//, "")}`;
+  }
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return { type: "unknown", normalized: raw };
+  }
+  if (!IG_HOST.test(url.hostname)) {
+    return { type: "unknown", normalized: raw };
+  }
+  const storyMediaId = url.searchParams.get("story_media_id") ?? void 0;
+  const parts = url.pathname.split("/").filter(Boolean);
+  if (parts[0] === "s" && parts[1]) {
+    const share = decodeShareSlug(parts[1]);
+    if (share?.type === "highlight") {
+      return {
+        type: "highlight",
+        highlightId: share.id,
+        storyMediaId,
+        normalized: buildNormalizedPath(`/stories/highlights/${share.id}`)
+      };
+    }
+  }
+  if (parts[0] === "reel" && parts[1]) {
+    return {
+      type: "reel",
+      shortcode: parts[1],
+      normalized: buildNormalizedPath(`/reel/${parts[1]}`)
+    };
+  }
+  if (parts[0] === "p" && parts[1]) {
+    return {
+      type: "post",
+      shortcode: parts[1],
+      normalized: buildNormalizedPath(`/p/${parts[1]}`)
+    };
+  }
+  if (parts[0] === "tv" && parts[1]) {
+    return {
+      type: "tv",
+      shortcode: parts[1],
+      normalized: buildNormalizedPath(`/tv/${parts[1]}`)
+    };
+  }
+  if (parts[0] === "stories" && parts[1]) {
+    if (parts[1] === "highlights" && parts[2]) {
+      return {
+        type: "highlight",
+        highlightId: parts[2],
+        storyMediaId,
+        normalized: buildNormalizedPath(`/stories/highlights/${parts[2]}`)
+      };
+    }
+    if (parts[2]) {
+      return {
+        type: "story",
+        username: parts[1],
+        storyId: parts[2],
+        normalized: buildNormalizedPath(`/stories/${parts[1]}/${parts[2]}`)
+      };
+    }
+    return {
+      type: "story",
+      username: parts[1],
+      normalized: buildNormalizedPath(`/stories/${parts[1]}`)
+    };
+  }
+  return { type: "unknown", normalized: buildNormalizedPath(url.pathname || "/") };
+}
+function isInstagramUrl(input) {
+  try {
+    const normalized = normalizeInstagramUrl(
+      input.startsWith("http") ? input : `https://${input}`
+    );
+    const parsed = parseInstagramUrl(normalized);
+    return parsed.type !== "unknown";
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/validators.ts
+init_esm_shims();
+function validateUrl(input) {
+  if (!input || typeof input !== "string") {
+    return { valid: false, error: "URL must be a non-empty string" };
+  }
+  try {
+    new URL(input.startsWith("http") ? input : `https://${input}`);
+  } catch {
+    return { valid: false, error: "Invalid URL format" };
+  }
+  if (!isInstagramUrl(input)) {
+    return { valid: false, error: "Not a supported Instagram URL" };
+  }
+  const parsed = parseInstagramUrl(input);
+  return {
+    valid: true,
+    type: parsed.type,
+    normalized: parsed.normalized
+  };
+}
+
+// src/core/downloader.ts
+init_logger();
+var pendingDownloads = /* @__PURE__ */ new Map();
+function hasStoryVideo(media) {
+  return media.some((m) => m.type === "video" && isCdnMediaUrl(m.url));
+}
+function hasReelVideo(media) {
+  return media.some((m) => m.type === "video" && isCdnMediaUrl(m.url));
+}
+var DownloaderCore = class {
+  client;
+  cache;
+  options;
+  startTime = Date.now();
+  semaphore;
+  constructor(options = {}) {
+    const fastMode = options.fastMode === true;
+    const responseBudgetMs = fastMode ? 500 : options.responseBudgetMs;
+    this.options = {
+      cache: true,
+      cacheTtlMs: 3e5,
+      staleCacheTtlMs: 864e5,
+      cacheMaxSize: 500,
+      maxConcurrency: 100,
+      timeoutMs: 8e3,
+      retries: 2,
+      userAgentRotation: true,
+      ...options,
+      responseBudgetMs,
+      fastMode
+    };
+    if (responseBudgetMs) {
+      this.options.retries = 0;
+      this.options.cache = this.options.cache !== false;
+    }
+    this.client = new HttpClient({
+      timeoutMs: this.options.timeoutMs,
+      retries: this.options.retries,
+      userAgentRotation: this.options.userAgentRotation
+    });
+    this.cache = new ResponseCache({
+      maxSize: this.options.cacheMaxSize,
+      ttlMs: this.options.cacheTtlMs,
+      staleTtlMs: this.options.staleCacheTtlMs,
+      redis: this.options.redis
+    });
+    this.semaphore = {
+      max: this.options.maxConcurrency ?? 100,
+      current: 0,
+      queue: []
+    };
+  }
+  async acquire() {
+    if (this.semaphore.current < this.semaphore.max) {
+      this.semaphore.current++;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.semaphore.queue.push(() => {
+        this.semaphore.current++;
+        resolve();
+      });
+    });
+  }
+  release() {
+    this.semaphore.current--;
+    const next = this.semaphore.queue.shift();
+    if (next) next();
+  }
+  meta() {
+    return { extractor: EXTRACTOR_NAME, version: PACKAGE_VERSION };
+  }
+  success(data) {
+    return {
+      code: 200,
+      meta: this.meta(),
+      media: data.media,
+      caption: data.caption,
+      username: data.username,
+      engagement: data.engagement,
+      tags: data.tags
+    };
+  }
+  error(code, message, retryAfterMs) {
+    return { code, message, meta: this.meta(), retryAfterMs };
+  }
+  startDownloadTask(cacheKey, parsed) {
+    return (async () => {
+      await this.acquire();
+      try {
+        const result = await this.fetchAndExtract(parsed);
+        if (this.options.cache !== false && result.code === 200) {
+          this.cache.set(cacheKey, result);
+        }
+        return result;
+      } catch (err) {
+        logger.error("Background extraction failed", err);
+        return this.error(500, err instanceof Error ? err.message : "Extraction failed");
+      } finally {
+        this.release();
+      }
+    })();
+  }
+  /** API-only attempt for story/highlight (fits ~500ms budget). */
+  async fetchFastExtract(parsed) {
+    const budget = this.options.responseBudgetMs;
+    if (!budget) return null;
+    const sessionCookie = buildSessionCookie(
+      this.options.sessionId,
+      this.options.cookies
+    );
+    if (!sessionCookie || !sessionCookieReady(sessionCookie)) return null;
+    const apiMs = Math.max(250, budget - 80);
+    try {
+      if (parsed.type === "story" && parsed.storyId) {
+        const fromApi = await fetchMediaInfoByPk(
+          parsed.storyId,
+          sessionCookie,
+          parsed.normalized,
+          userIdFromCookie(sessionCookie) ?? void 0,
+          apiMs
+        );
+        const media = filterValidMedia(fromApi?.media ?? []);
+        if (!hasStoryVideo(media)) return null;
+        const extracted = normalizeExtraction(
+          {
+            ...fromApi,
+            media,
+            caption: "",
+            username: parsed.username ?? fromApi.username
+          },
+          parsed,
+          {},
+          ""
+        );
+        return extracted?.media.length ? this.success(extracted) : null;
+      }
+      if (parsed.type === "highlight" && parsed.storyMediaId) {
+        const pk = parsed.storyMediaId.split("_")[0];
+        const ownerId = parsed.storyMediaId.split("_")[1];
+        const fromApi = await fetchMediaInfoByPk(
+          pk,
+          sessionCookie,
+          parsed.normalized,
+          ownerId,
+          apiMs
+        );
+        const media = filterValidMedia(fromApi?.media ?? []);
+        if (!media.some((m) => m.type === "video" && isCdnMediaUrl(m.url))) return null;
+        const extracted = normalizeExtraction(
+          {
+            ...fromApi,
+            media,
+            caption: fromApi.caption ?? "",
+            username: parsed.username ?? fromApi.username
+          },
+          parsed,
+          {},
+          ""
+        );
+        return extracted?.media.length ? this.success(extracted) : null;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  /** Warm cache in background (full extraction, no response budget). */
+  prefetch(url) {
+    const validation = validateUrl(url);
+    if (!validation.valid) {
+      return Promise.resolve(this.error(400, validation.error ?? "Invalid URL"));
+    }
+    const parsed = parseInstagramUrl(url);
+    const cacheKey = parsed.normalized;
+    let task = pendingDownloads.get(cacheKey);
+    if (!task) {
+      task = this.startDownloadTask(cacheKey, parsed);
+      pendingDownloads.set(cacheKey, task);
+      void task.finally(() => pendingDownloads.delete(cacheKey));
+    }
+    return task;
+  }
+  async download(url) {
+    const validation = validateUrl(url);
+    if (!validation.valid) {
+      return this.error(400, validation.error ?? "Invalid URL");
+    }
+    const parsed = parseInstagramUrl(url);
+    const cacheKey = parsed.normalized;
+    const budget = this.options.responseBudgetMs;
+    if (this.options.cache !== false) {
+      const fresh = this.cache.getFreshSync(cacheKey);
+      if (fresh) {
+        logger.debug(`Cache hit (sync) for ${cacheKey}`);
+        return fresh;
+      }
+      const stale = this.cache.getStaleSync(cacheKey);
+      if (stale) {
+        logger.debug(`Stale cache hit for ${cacheKey}`);
+        this.ensureBackgroundFetch(cacheKey, parsed);
+        return stale;
+      }
+      if (!budget) {
+        const cached = await this.cache.get(cacheKey);
+        if (cached) {
+          logger.debug(`Cache hit for ${cacheKey}`);
+          return cached;
+        }
+      }
+    }
+    const inFlight2 = pendingDownloads.get(cacheKey);
+    if (inFlight2) {
+      return inFlight2;
+    }
+    const task = this.startDownloadTask(cacheKey, parsed);
+    pendingDownloads.set(cacheKey, task);
+    void task.finally(() => pendingDownloads.delete(cacheKey));
+    if (!budget) {
+      return task;
+    }
+    const fastAttempt = this.fetchFastExtract(parsed);
+    const raced = await Promise.race([
+      fastAttempt,
+      task,
+      sleep(budget).then(() => null)
+    ]);
+    if (raced) {
+      if (raced.code === 200 && this.options.cache !== false) {
+        this.cache.set(cacheKey, raced);
+      }
+      return raced;
+    }
+    const retryAfterMs = Math.max(200, Math.min(500, budget));
+    return this.error(
+      503,
+      "Response budget exceeded \u2014 fetch still running; retry the same URL immediately",
+      retryAfterMs
+    );
+  }
+  ensureBackgroundFetch(cacheKey, parsed) {
+    if (pendingDownloads.has(cacheKey)) return;
+    const task = this.startDownloadTask(cacheKey, parsed);
+    pendingDownloads.set(cacheKey, task);
+    void task.finally(() => pendingDownloads.delete(cacheKey));
+  }
+  async fetchAndExtract(parsed) {
+    const resolvedUrl = resolveFetchUrl(parsed);
+    try {
+      let sessionCookie = buildSessionCookie(
+        this.options.sessionId,
+        this.options.cookies
+      );
+      const sessionTypes = parsed.type === "story" || parsed.type === "highlight";
+      const embedUrl = resolveEmbedUrl(parsed);
+      let prefetchApiData = null;
+      let body = "";
+      let statusCode = 200;
+      let embedBody = "";
+      const ensureSession = async (cookie) => {
+        if (sessionCookieReady(cookie)) return cookie;
+        return enrichSessionCookie(cookie);
+      };
+      if (sessionCookie && parsed.type === "story" && parsed.storyId) {
+        sessionCookie = await ensureSession(sessionCookie);
+        const fromApi = await fetchMediaInfoByPk(
+          parsed.storyId,
+          sessionCookie,
+          parsed.normalized,
+          userIdFromCookie(sessionCookie) ?? void 0
+        );
+        const apiMedia = filterValidMedia(fromApi?.media ?? []);
+        if (hasStoryVideo(apiMedia)) {
+          const extracted2 = normalizeExtraction(
+            {
+              ...fromApi,
+              media: apiMedia,
+              caption: fromApi.caption ?? "",
+              username: parsed.username ?? fromApi.username
+            },
+            parsed,
+            {},
+            ""
+          );
+          if (extracted2?.media.length) {
+            return this.success(extracted2);
+          }
+        }
+        prefetchApiData = fromApi;
+      } else if (sessionCookie && parsed.type === "highlight" && parsed.storyMediaId) {
+        sessionCookie = await ensureSession(sessionCookie);
+        const pk = parsed.storyMediaId.split("_")[0];
+        const ownerId = parsed.storyMediaId.split("_")[1];
+        const [fromApi, pageRes] = await Promise.all([
+          fetchMediaInfoByPk(pk, sessionCookie, parsed.normalized, ownerId),
+          this.client.fetchWithCookie(resolvedUrl, sessionCookie)
+        ]);
+        body = pageRes.body;
+        statusCode = pageRes.statusCode;
+        const apiMedia = filterValidMedia(fromApi?.media ?? []);
+        if (apiMedia.some((m) => m.type === "video" && isCdnMediaUrl(m.url))) {
+          const pageMeta2 = extractPageMeta(body);
+          const extracted2 = normalizeExtraction(
+            {
+              ...fromApi,
+              media: apiMedia,
+              caption: fromApi.caption ?? "",
+              username: parsed.username ?? fromApi.username
+            },
+            parsed,
+            { ...pageMeta2, html: body },
+            body
+          );
+          if (extracted2?.media.length) {
+            return this.success(extracted2);
+          }
+        }
+        prefetchApiData = fromApi;
+      } else if (sessionCookie && parsed.type === "post" && parsed.shortcode) {
+        sessionCookie = await ensureSession(sessionCookie);
+        const mediaPk = shortcodeToMediaPk(parsed.shortcode);
+        const ownerId = userIdFromCookie(sessionCookie) ?? void 0;
+        const pagePromise = this.client.fetchWithCookie(resolvedUrl, sessionCookie);
+        if (mediaPk) {
+          const [fromApi, pageRes] = await Promise.all([
+            fetchMediaInfoByPk(mediaPk, sessionCookie, parsed.normalized, ownerId),
+            pagePromise
+          ]);
+          prefetchApiData = fromApi;
+          body = pageRes.body;
+          statusCode = pageRes.statusCode;
+        } else {
+          const pageRes = await pagePromise;
+          body = pageRes.body;
+          statusCode = pageRes.statusCode;
+        }
+      }
+      if (!body) {
+        if (sessionCookie && sessionTypes) {
+          sessionCookie = await ensureSession(sessionCookie);
+          const res = await this.client.fetchWithCookie(resolvedUrl, sessionCookie);
+          body = res.body;
+          statusCode = res.statusCode;
+        } else {
+          const res = await this.client.fetch(resolvedUrl);
+          body = res.body;
+          statusCode = res.statusCode;
+        }
+      }
+      if (statusCode === 404) {
+        return this.error(404, "Media not found");
+      }
+      if (statusCode === 429) {
+        return this.error(429, "Rate limited");
+      }
+      const pageMeta = extractPageMeta(body);
+      const ctx = { html: body, url: resolvedUrl, parsed, sessionCookie };
+      const prefetchedMedia = prefetchApiData ? filterValidMedia(prefetchApiData.media) : [];
+      let extracted;
+      if (parsed.type === "story" && prefetchedMedia.length && hasStoryVideo(prefetchedMedia)) {
+        extracted = {
+          ...prefetchApiData,
+          media: prefetchedMedia,
+          username: parsed.username ?? prefetchApiData.username
+        };
+      } else {
+        extracted = await runExtractor(ctx);
+        if (prefetchApiData) {
+          extracted = mergeExtracted(extracted, prefetchApiData);
+        }
+      }
+      if (parsed.type === "post" && prefetchApiData) {
+        const apiMedia = filterValidMedia(prefetchApiData.media);
+        const htmlCount = filterValidMedia(extracted?.media ?? []).length;
+        if (apiMedia.length >= 2 || apiMedia.length > htmlCount) {
+          extracted = {
+            ...extracted ?? { media: [], caption: "", username: "" },
+            ...prefetchApiData,
+            media: apiMedia,
+            caption: prefetchApiData.caption || extracted?.caption || "",
+            username: prefetchApiData.username || extracted?.username || "",
+            engagement: prefetchApiData.engagement ?? extracted?.engagement
+          };
+        }
+      }
+      const validExtracted = filterValidMedia(extracted?.media ?? []);
+      if (parsed.type === "story" && sessionCookie && !hasStoryVideo(validExtracted)) {
+        logger.debug("Trying story API with session cookie");
+        const fromApi = await fetchStoryViaSession(parsed, sessionCookie, body);
+        extracted = mergeExtracted(extracted, fromApi);
+      }
+      let embedCaption = "";
+      let captionEmbedHtml = "";
+      const captionEmbedUrl = contentTypesWithEmbedCaption(parsed.type) ? captionedEmbedUrl(parsed) : null;
+      const enrichmentTasks = [];
+      if (captionEmbedUrl) {
+        enrichmentTasks.push(
+          (async () => {
+            try {
+              const capRes = await this.client.fetch(captionEmbedUrl, false);
+              captionEmbedHtml = capRes.body;
+              embedCaption = parseCaptionFromCaptionedEmbed(capRes.body, parsed.type);
+            } catch {
+            }
+          })()
+        );
+      }
+      if (parsed.type === "post" && parsed.shortcode && imageNeedsHigherResolution(extracted?.media ?? [])) {
+        enrichmentTasks.push(
+          (async () => {
+            const large = await fetchPostLargeImageUrl(parsed.shortcode);
+            if (large && extracted?.media.length) {
+              extracted = {
+                ...extracted,
+                media: applyLargePostImage(extracted.media, large)
+              };
+            }
+          })()
+        );
+      }
+      if (enrichmentTasks.length) {
+        await Promise.all(enrichmentTasks);
+      }
+      if ((parsed.type === "reel" || parsed.type === "tv") && !hasReelVideo(extracted?.media ?? []) && captionEmbedHtml) {
+        extracted = mergeExtracted(extracted, parseEmbedHtml(captionEmbedHtml));
+      }
+      const postHtml = body;
+      const carouselHintEarly = parsed.type === "post" && htmlIndicatesCarouselPost(postHtml);
+      const needPostEmbed = parsed.type === "post" && embedUrl && (postNeedsEmbedFetch(extracted?.media ?? []) || carouselHintEarly);
+      const needReelEmbed = (parsed.type === "reel" || parsed.type === "tv") && embedUrl && needsVideoEmbedFallback(parsed, extracted);
+      if (needPostEmbed || needReelEmbed) {
+        logger.debug(`Fetching embed: ${embedUrl}`);
+        const embedRes = await this.client.fetch(embedUrl, false);
+        embedBody = embedRes.body;
+        if (needReelEmbed) {
+          const embedData = parseEmbedHtml(embedBody);
+          extracted = mergeExtracted(extracted, embedData);
+        } else {
+          const { parseHtml: parseHtmlLayers } = await Promise.resolve().then(() => (init_parser(), parser_exports));
+          const embedParsed = parseEmbedHtml(embedBody) ?? parseHtmlLayers(embedBody, "post");
+          extracted = mergeExtracted(extracted, embedParsed);
+        }
+      }
+      const dimensionHtmlPre = embedBody || captionEmbedHtml ? `${body}
+${embedBody}
+${captionEmbedHtml}` : body;
+      if ((parsed.type === "reel" || parsed.type === "tv") && sessionCookie && !hasReelVideo(extracted?.media ?? [])) {
+        const mediaPk = extractMediaPkFromHtml(dimensionHtmlPre);
+        if (mediaPk) {
+          logger.debug(`Reel API fallback for media pk=${mediaPk}`);
+          const fromApi = await fetchMediaInfoByPk(
+            mediaPk,
+            sessionCookie,
+            parsed.normalized
+          );
+          extracted = mergeExtracted(extracted, fromApi);
+        }
+      }
+      if (parsed.type === "post" && sessionCookie && parsed.shortcode) {
+        sessionCookie = await ensureSession(sessionCookie);
+        const htmlSlideCount = extracted?.media.length ?? 0;
+        const carouselHint = htmlIndicatesCarouselPost(dimensionHtmlPre);
+        const pkCandidates = postMediaPkCandidates(
+          parsed.shortcode,
+          dimensionHtmlPre,
+          extracted?.media ?? []
+        );
+        let bestApi = null;
+        for (const mediaPk of pkCandidates) {
+          logger.debug(`Post API carousel pk=${mediaPk}`);
+          const fromApi = await fetchMediaInfoByPk(
+            mediaPk,
+            sessionCookie,
+            parsed.normalized,
+            userIdFromCookie(sessionCookie) ?? void 0
+          );
+          const apiMedia2 = filterValidMedia(fromApi?.media ?? []);
+          if (fromApi && apiMedia2.length > (bestApi?.media.length ?? 0)) {
+            bestApi = { ...fromApi, media: apiMedia2 };
+          }
+        }
+        const apiMedia = filterValidMedia(bestApi?.media ?? []);
+        const apiImprovesCarousel = apiMedia.length >= 2 || apiMedia.length > htmlSlideCount || carouselHint && apiMedia.length > htmlSlideCount;
+        if (bestApi && apiImprovesCarousel) {
+          extracted = {
+            ...extracted,
+            ...bestApi,
+            media: apiMedia,
+            caption: bestApi.caption || extracted?.caption || "",
+            username: bestApi.username || extracted?.username || "",
+            engagement: bestApi.engagement ?? extracted?.engagement
+          };
+        }
+      }
+      const storyEmbedUrl = resolveStoryEmbedUrl(parsed);
+      if (storyEmbedUrl && parsed.type === "story" && !hasStoryVideo(extracted?.media ?? [])) {
+        logger.debug(`Fetching story embed: ${storyEmbedUrl}`);
+        const storyEmbedRes = await this.client.fetch(storyEmbedUrl, false);
+        const storyEmbedData = parseEmbedHtml(storyEmbedRes.body);
+        extracted = mergeExtracted(extracted, storyEmbedData);
+        if (!extracted?.media.some((m) => m.type === "video")) {
+          const { parseHtml: parseHtml2 } = await Promise.resolve().then(() => (init_parser(), parser_exports));
+          extracted = mergeExtracted(extracted, parseHtml2(storyEmbedRes.body));
+        }
+      }
+      const dimensionHtml = dimensionHtmlPre;
+      extracted = normalizeExtraction(
+        extracted,
+        parsed,
+        { ...pageMeta, html: dimensionHtml, embedCaption },
+        dimensionHtml
+      );
+      if (extracted && parsed.type === "post") {
+        const contentTags = buildPostContentTags(
+          parsed.type,
+          extracted.media.length,
+          dimensionHtml,
+          Boolean(sessionCookie)
+        );
+        extracted = {
+          ...extracted,
+          tags: mergeResultTags(extracted.tags, contentTags)
+        };
+      }
+      if (extracted?.media.length) {
+        extracted = {
+          ...extracted,
+          media: extracted.media.map((m) => {
+            if (m.type !== "video" || isValidThumbnailUrl(m.thumbnail)) return m;
+            const { thumbnail: _t, ...rest } = m;
+            return rest;
+          })
+        };
+      }
+      if (extracted?.isPrivate) {
+        return this.error(403, "Private account");
+      }
+      if (!extracted?.media.length) {
+        const msg = parsed.type === "story" ? sessionCookie ? "Story not found or expired (check sessionId and that the story is still active)" : "Story media requires sessionId \u2014 Instagram does not expose story CDN URLs to logged-out requests. Pass options.sessionId from a logged-in browser cookie." : parsed.type === "reel" || parsed.type === "tv" ? sessionCookie ? "Reel video not found \u2014 reel may be unavailable or session expired" : "Reel video requires INSTAGRAM_SESSION_ID or INSTAGRAM_COOKIES \u2014 Instagram no longer exposes reel MP4 URLs in public HTML" : "Media not found";
+        return this.error(404, msg);
+      }
+      return this.success(extracted);
+    } catch (err) {
+      const code = err?.code ?? err?.statusCode;
+      if (code === 429) return this.error(429, "Rate limited");
+      if (err instanceof Error && err.name === "AbortError") {
+        return this.error(504, "Request timed out");
+      }
+      logger.error("Extraction failed", err);
+      return this.error(500, err instanceof Error ? err.message : "Extraction failed");
+    }
+  }
+  async info(url) {
+    return this.download(url);
+  }
+  async validate(url) {
+    return validateUrl(url);
+  }
+  async media(url) {
+    const result = await this.download(url);
+    if (result.code !== 200) return result;
+    return result.media;
+  }
+  async batch(urls) {
+    const tasks = urls.map(async (url) => {
+      const start = Date.now();
+      const result = await this.download(url);
+      return { url, result, durationMs: Date.now() - start };
+    });
+    return Promise.all(tasks);
+  }
+  async health() {
+    const stats = this.cache.getStats();
+    const pool = getPoolStats();
+    return {
+      status: "ok",
+      version: PACKAGE_VERSION,
+      uptime: Date.now() - this.startTime,
+      cache: {
+        size: stats.size,
+        maxSize: stats.maxSize,
+        hitRate: stats.hitRate
+      },
+      pool: {
+        connections: pool.connections,
+        pending: this.client.getInFlightCount()
+      }
+    };
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+};
+
+// src/index.ts
+var ultraigdl = class {
+  core;
+  constructor(options) {
+    this.core = new DownloaderCore(options);
+  }
+  download(url) {
+    return this.core.download(url);
+  }
+  info(url) {
+    return this.core.info(url);
+  }
+  validate(url) {
+    return this.core.validate(url);
+  }
+  media(url) {
+    return this.core.media(url);
+  }
+  batch(urls) {
+    return this.core.batch(urls);
+  }
+  health() {
+    return this.core.health();
+  }
+  clearCache() {
+    this.core.clearCache();
+  }
+  /** Start extraction now so the next `download()` can return within `responseBudgetMs`. */
+  prefetch(url) {
+    return this.core.prefetch(url);
+  }
+};
+var src_default = ultraigdl;
+export {
+  DownloaderCore,
+  EXTRACTOR_NAME,
+  PACKAGE_VERSION,
+  src_default as default,
+  isInstagramUrl,
+  parseInstagramUrl,
+  ultraigdl,
+  validateUrl
+};
+//# sourceMappingURL=index.js.map