@vicociv/instaloader 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3641 @@
+// src/exceptions.ts
+var InstaloaderException = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InstaloaderException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var QueryReturnedBadRequestException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "QueryReturnedBadRequestException";
+  }
+};
+var QueryReturnedForbiddenException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "QueryReturnedForbiddenException";
+  }
+};
+var ProfileNotExistsException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "ProfileNotExistsException";
+  }
+};
+var ProfileHasNoPicsException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "ProfileHasNoPicsException";
+  }
+};
+var PrivateProfileNotFollowedException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "PrivateProfileNotFollowedException";
+  }
+};
+var LoginRequiredException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "LoginRequiredException";
+  }
+};
+var LoginException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "LoginException";
+  }
+};
+var TwoFactorAuthRequiredException = class extends LoginException {
+  twoFactorInfo;
+  constructor(twoFactorInfo, message) {
+    super(message ?? "Two-factor authentication required");
+    this.name = "TwoFactorAuthRequiredException";
+    this.twoFactorInfo = twoFactorInfo;
+  }
+};
+var InvalidArgumentException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidArgumentException";
+  }
+};
+var BadResponseException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "BadResponseException";
+  }
+};
+var BadCredentialsException = class extends LoginException {
+  constructor(message) {
+    super(message);
+    this.name = "BadCredentialsException";
+  }
+};
+var ConnectionException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectionException";
+  }
+};
+var PostChangedException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "PostChangedException";
+  }
+};
+var QueryReturnedNotFoundException = class extends ConnectionException {
+  constructor(message) {
+    super(message);
+    this.name = "QueryReturnedNotFoundException";
+  }
+};
+var TooManyRequestsException = class extends ConnectionException {
+  constructor(message) {
+    super(message);
+    this.name = "TooManyRequestsException";
+  }
+};
+var IPhoneSupportDisabledException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "IPhoneSupportDisabledException";
+  }
+};
+var AbortDownloadException = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbortDownloadException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SessionNotFoundException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "SessionNotFoundException";
+  }
+};
+var CheckpointRequiredException = class extends ConnectionException {
+  checkpointUrl;
+  constructor(message, checkpointUrl) {
+    super(message);
+    this.name = "CheckpointRequiredException";
+    this.checkpointUrl = checkpointUrl;
+  }
+};
+var InvalidIteratorException = class extends InstaloaderException {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidIteratorException";
+  }
+};
+
+// src/instaloadercontext.ts
+import { CookieJar, Cookie } from "tough-cookie";
+import { v4 as uuidv4 } from "uuid";
+function defaultUserAgent() {
+  return "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
+}
+function defaultIphoneHeaders() {
+  const timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset() * -60;
+  return {
+    "User-Agent": "Instagram 361.0.0.35.82 (iPad13,8; iOS 18_0; en_US; en-US; scale=2.00; 2048x2732; 674117118) AppleWebKit/420+",
+    "x-ads-opt-out": "1",
+    "x-bloks-is-panorama-enabled": "true",
+    "x-bloks-version-id": "16b7bd25c6c06886d57c4d455265669345a2d96625385b8ee30026ac2dc5ed97",
+    "x-fb-client-ip": "True",
+    "x-fb-connection-type": "wifi",
+    "x-fb-http-engine": "Liger",
+    "x-fb-server-cluster": "True",
+    "x-fb": "1",
+    "x-ig-abr-connection-speed-kbps": "2",
+    "x-ig-app-id": "124024574287414",
+    "x-ig-app-locale": "en-US",
+    "x-ig-app-startup-country": "US",
+    "x-ig-bandwidth-speed-kbps": "0.000",
+    "x-ig-capabilities": "36r/F/8=",
+    "x-ig-connection-speed": `${Math.floor(Math.random() * 19e3) + 1e3}kbps`,
+    "x-ig-connection-type": "WiFi",
+    "x-ig-device-locale": "en-US",
+    "x-ig-mapped-locale": "en-US",
+    "x-ig-timezone-offset": String(timezoneOffset),
+    "x-ig-www-claim": "0",
+    "x-pigeon-session-id": uuidv4(),
+    "x-tigon-is-retry": "False",
+    "x-whatsapp": "0"
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function exponentialVariate(lambda) {
+  return -Math.log(1 - Math.random()) / lambda;
+}
+var RateController = class {
+  _context;
+  _queryTimestamps = /* @__PURE__ */ new Map();
+  _earliestNextRequestTime = 0;
+  _iphoneEarliestNextRequestTime = 0;
+  constructor(context) {
+    this._context = context;
+  }
+  /**
+   * Wait given number of seconds.
+   */
+  async sleep(secs) {
+    await sleep(secs * 1e3);
+  }
+  /**
+   * Return how many requests of the given type can be done within a sliding window of 11 minutes.
+   */
+  countPerSlidingWindow(queryType) {
+    return queryType === "other" ? 75 : 200;
+  }
+  _reqsInSlidingWindow(queryType, currentTime, window) {
+    if (queryType !== null) {
+      const timestamps = this._queryTimestamps.get(queryType) || [];
+      return timestamps.filter((t) => t > currentTime - window);
+    } else {
+      const allTimestamps = [];
+      for (const [type, times] of this._queryTimestamps) {
+        if (type !== "iphone" && type !== "other") {
+          allTimestamps.push(...times.filter((t) => t > currentTime - window));
+        }
+      }
+      return allTimestamps;
+    }
+  }
+  /**
+   * Calculate time needed to wait before query can be executed.
+   */
+  queryWaittime(queryType, currentTime, untrackedQueries = false) {
+    const perTypeSlidingWindow = 660;
+    const iphoneSlidingWindow = 1800;
+    if (!this._queryTimestamps.has(queryType)) {
+      this._queryTimestamps.set(queryType, []);
+    }
+    const timestamps = this._queryTimestamps.get(queryType);
+    const filteredTimestamps = timestamps.filter(
+      (t) => t > currentTime - 60 * 60
+    );
+    this._queryTimestamps.set(queryType, filteredTimestamps);
+    const perTypeNextRequestTime = () => {
+      const reqs = this._reqsInSlidingWindow(
+        queryType,
+        currentTime,
+        perTypeSlidingWindow
+      );
+      if (reqs.length < this.countPerSlidingWindow(queryType)) {
+        return 0;
+      } else {
+        return Math.min(...reqs) + perTypeSlidingWindow + 6;
+      }
+    };
+    const gqlAccumulatedNextRequestTime = () => {
+      if (queryType === "iphone" || queryType === "other") {
+        return 0;
+      }
+      const gqlAccumulatedSlidingWindow = 600;
+      const gqlAccumulatedMaxCount = 275;
+      const reqs = this._reqsInSlidingWindow(
+        null,
+        currentTime,
+        gqlAccumulatedSlidingWindow
+      );
+      if (reqs.length < gqlAccumulatedMaxCount) {
+        return 0;
+      } else {
+        return Math.min(...reqs) + gqlAccumulatedSlidingWindow;
+      }
+    };
+    const untrackedNextRequestTime = () => {
+      if (untrackedQueries) {
+        if (queryType === "iphone") {
+          const reqs = this._reqsInSlidingWindow(
+            queryType,
+            currentTime,
+            iphoneSlidingWindow
+          );
+          this._iphoneEarliestNextRequestTime = Math.min(...reqs) + iphoneSlidingWindow + 18;
+        } else {
+          const reqs = this._reqsInSlidingWindow(
+            queryType,
+            currentTime,
+            perTypeSlidingWindow
+          );
+          this._earliestNextRequestTime = Math.min(...reqs) + perTypeSlidingWindow + 6;
+        }
+      }
+      return Math.max(
+        this._iphoneEarliestNextRequestTime,
+        this._earliestNextRequestTime
+      );
+    };
+    const iphoneNextRequest = () => {
+      if (queryType === "iphone") {
+        const reqs = this._reqsInSlidingWindow(
+          queryType,
+          currentTime,
+          iphoneSlidingWindow
+        );
+        if (reqs.length >= 199) {
+          return Math.min(...reqs) + iphoneSlidingWindow + 18;
+        }
+      }
+      return 0;
+    };
+    return Math.max(
+      0,
+      Math.max(
+        perTypeNextRequestTime(),
+        gqlAccumulatedNextRequestTime(),
+        untrackedNextRequestTime(),
+        iphoneNextRequest()
+      ) - currentTime
+    );
+  }
+  /**
+   * Called before a query to Instagram.
+   */
+  async waitBeforeQuery(queryType) {
+    const currentTime = Date.now() / 1e3;
+    const waittime = this.queryWaittime(queryType, currentTime, false);
+    if (waittime > 15) {
+      const formattedWaittime = waittime <= 666 ? `${Math.round(waittime)} seconds` : `${Math.round(waittime / 60)} minutes`;
+      const resumeTime = new Date(Date.now() + waittime * 1e3);
+      this._context.log(
+        `
+Too many queries in the last time. Need to wait ${formattedWaittime}, until ${resumeTime.toLocaleTimeString()}.`
+      );
+    }
+    if (waittime > 0) {
+      await this.sleep(waittime);
+    }
+    if (!this._queryTimestamps.has(queryType)) {
+      this._queryTimestamps.set(queryType, [Date.now() / 1e3]);
+    } else {
+      this._queryTimestamps.get(queryType).push(Date.now() / 1e3);
+    }
+  }
+  /**
+   * Handle a 429 Too Many Requests response.
+   */
+  async handle429(queryType) {
+    const currentTime = Date.now() / 1e3;
+    const waittime = this.queryWaittime(queryType, currentTime, true);
+    const text429 = 'Instagram responded with HTTP error "429 - Too Many Requests". Please do not run multiple instances of Instaloader in parallel or within short sequence. Also, do not use any Instagram App while Instaloader is running.';
+    this._context.error(text429);
+    if (waittime > 1.5) {
+      const formattedWaittime = waittime <= 666 ? `${Math.round(waittime)} seconds` : `${Math.round(waittime / 60)} minutes`;
+      const resumeTime = new Date(Date.now() + waittime * 1e3);
+      this._context.error(
+        `The request will be retried in ${formattedWaittime}, at ${resumeTime.toLocaleTimeString()}.`
+      );
+    }
+    if (waittime > 0) {
+      await this.sleep(waittime);
+    }
+  }
+};
+var InstaloaderContext = class {
+  userAgent;
+  requestTimeout;
+  maxConnectionAttempts;
+  sleep;
+  quiet;
+  iphoneSupport;
+  fatalStatusCodes;
+  _cookieJar;
+  _csrfToken = null;
+  _username = null;
+  _userId = null;
+  _iphoneHeaders;
+  _rateController;
+  _errorLog = [];
+  _twoFactorAuthPending = null;
+  /** Raise all errors instead of catching them (for testing) */
+  raiseAllErrors = false;
+  /** Cache profile from id (mapping from id to Profile) */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  profile_id_cache = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.userAgent = options.userAgent ?? defaultUserAgent();
+    this.requestTimeout = options.requestTimeout ?? 3e5;
+    this.maxConnectionAttempts = options.maxConnectionAttempts ?? 3;
+    this.sleep = options.sleep ?? true;
+    this.quiet = options.quiet ?? false;
+    this.iphoneSupport = options.iphoneSupport ?? true;
+    this.fatalStatusCodes = options.fatalStatusCodes ?? [];
+    this._cookieJar = new CookieJar();
+    this._iphoneHeaders = defaultIphoneHeaders();
+    this._initAnonymousCookies();
+    this._rateController = options.rateController ? options.rateController(this) : new RateController(this);
+  }
+  _initAnonymousCookies() {
+    const domain = "www.instagram.com";
+    const defaultCookies = {
+      sessionid: "",
+      mid: "",
+      ig_pr: "1",
+      ig_vw: "1920",
+      csrftoken: "",
+      s_network: "",
+      ds_user_id: ""
+    };
+    for (const [name, value] of Object.entries(defaultCookies)) {
+      const cookie = new Cookie({
+        key: name,
+        value,
+        domain,
+        path: "/"
+      });
+      this._cookieJar.setCookieSync(cookie, `https://${domain}/`);
+    }
+  }
+  /** True if this instance is logged in. */
+  get is_logged_in() {
+    return this._username !== null;
+  }
+  /** The username of the logged-in user, or null. */
+  get username() {
+    return this._username;
+  }
+  /** The user ID of the logged-in user, or null. */
+  get userId() {
+    return this._userId;
+  }
+  /** iPhone headers for API requests. */
+  get iphone_headers() {
+    return this._iphoneHeaders;
+  }
+  /** Whether any error has been reported and stored. */
+  get hasStoredErrors() {
+    return this._errorLog.length > 0;
+  }
+  /**
+   * Log a message to stdout (can be suppressed with quiet option).
+   * @param message - The message to log
+   * @param newline - Whether to add a newline (default true, false for inline messages)
+   */
+  log(message, newline = true) {
+    if (!this.quiet) {
+      if (newline) {
+        console.log(message);
+      } else {
+        process.stdout.write(message);
+      }
+    }
+  }
+  /**
+   * Log a non-fatal error message to stderr.
+   */
+  error(message, repeatAtEnd = true) {
+    console.error(message);
+    if (repeatAtEnd) {
+      this._errorLog.push(message);
+    }
+  }
+  /**
+   * Close the context and print any stored errors.
+   */
+  close() {
+    if (this._errorLog.length > 0 && !this.quiet) {
+      console.error("\nErrors or warnings occurred:");
+      for (const err of this._errorLog) {
+        console.error(err);
+      }
+    }
+  }
+  /**
+   * Returns default HTTP headers for requests.
+   */
+  _defaultHttpHeader(emptySessionOnly = false) {
+    const header = {
+      "Accept-Encoding": "gzip, deflate",
+      "Accept-Language": "en-US,en;q=0.8",
+      Connection: "keep-alive",
+      "Content-Length": "0",
+      Host: "www.instagram.com",
+      Origin: "https://www.instagram.com",
+      Referer: "https://www.instagram.com/",
+      "User-Agent": this.userAgent,
+      "X-Instagram-AJAX": "1",
+      "X-Requested-With": "XMLHttpRequest"
+    };
+    if (emptySessionOnly) {
+      delete header["Host"];
+      delete header["Origin"];
+      delete header["X-Instagram-AJAX"];
+      delete header["X-Requested-With"];
+    }
+    return header;
+  }
+  /**
+   * Sleep a short time if sleep is enabled.
+   */
+  async doSleep() {
+    if (this.sleep) {
+      const sleepTime = Math.min(exponentialVariate(0.6), 15);
+      await sleep(sleepTime * 1e3);
+    }
+  }
+  /**
+   * Get cookies as a plain object.
+   */
+  getCookies(url = "https://www.instagram.com/") {
+    const cookies = this._cookieJar.getCookiesSync(url);
+    const result = {};
+    for (const cookie of cookies) {
+      result[cookie.key] = cookie.value;
+    }
+    return result;
+  }
+  /**
+   * Set cookies from a plain object.
+   */
+  setCookies(cookies, url = "https://www.instagram.com/") {
+    const domain = new URL(url).hostname;
+    for (const [name, value] of Object.entries(cookies)) {
+      const cookie = new Cookie({
+        key: name,
+        value,
+        domain,
+        path: "/"
+      });
+      this._cookieJar.setCookieSync(cookie, url);
+    }
+  }
+  /**
+   * Save session data for later restoration.
+   */
+  saveSession() {
+    return this.getCookies();
+  }
+  /**
+   * Load session data from a saved session.
+   */
+  loadSession(username, sessionData) {
+    this._cookieJar = new CookieJar();
+    this.setCookies(sessionData);
+    this._csrfToken = sessionData["csrftoken"] || null;
+    this._username = username;
+    this._userId = sessionData["ds_user_id"] || null;
+  }
+  /**
+   * Update cookies with new values.
+   */
+  updateCookies(cookies) {
+    this.setCookies(cookies);
+  }
+  /**
+   * Build cookie header string from cookie jar.
+   */
+  _getCookieHeader(url) {
+    const cookies = this._cookieJar.getCookiesSync(url);
+    return cookies.map((c) => `${c.key}=${c.value}`).join("; ");
+  }
+  /**
+   * Parse and store cookies from Set-Cookie headers.
+   */
+  _storeCookies(url, headers) {
+    const setCookies = headers.getSetCookie?.() || [];
+    for (const cookieStr of setCookies) {
+      try {
+        const cookie = Cookie.parse(cookieStr);
+        if (cookie) {
+          this._cookieJar.setCookieSync(cookie, url);
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Format response error message.
+   */
+  _responseError(status, statusText, url, respJson) {
+    let extraFromJson = null;
+    if (respJson && "status" in respJson) {
+      if ("message" in respJson) {
+        extraFromJson = `"${respJson["status"]}" status, message "${respJson["message"]}"`;
+      } else {
+        extraFromJson = `"${respJson["status"]}" status`;
+      }
+    }
+    return `${status} ${statusText}${extraFromJson ? ` - ${extraFromJson}` : ""} when accessing ${url}`;
+  }
+  /**
+   * Make a JSON request to Instagram.
+   */
+  async getJson(path2, params, options = {}) {
+    const {
+      host = "www.instagram.com",
+      usePost = false,
+      attempt = 1,
+      headers: extraHeaders
+    } = options;
+    const isGraphqlQuery = "query_hash" in params && path2.includes("graphql/query");
+    const isDocIdQuery = "doc_id" in params && path2.includes("graphql/query");
+    const isIphoneQuery = host === "i.instagram.com";
+    const isOtherQuery = !isGraphqlQuery && !isDocIdQuery && host === "www.instagram.com";
+    try {
+      await this.doSleep();
+      if (isGraphqlQuery) {
+        await this._rateController.waitBeforeQuery(params["query_hash"]);
+      }
+      if (isDocIdQuery) {
+        await this._rateController.waitBeforeQuery(params["doc_id"]);
+      }
+      if (isIphoneQuery) {
+        await this._rateController.waitBeforeQuery("iphone");
+      }
+      if (isOtherQuery) {
+        await this._rateController.waitBeforeQuery("other");
+      }
+      const url = new URL(`https://${host}/${path2}`);
+      const headers = {
+        ...this._defaultHttpHeader(true),
+        Cookie: this._getCookieHeader(url.toString()),
+        ...extraHeaders
+      };
+      if (this._csrfToken) {
+        headers["X-CSRFToken"] = this._csrfToken;
+      }
+      let response;
+      if (usePost) {
+        const body = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+          body.append(key, typeof value === "string" ? value : JSON.stringify(value));
+        }
+        headers["Content-Type"] = "application/x-www-form-urlencoded";
+        delete headers["Content-Length"];
+        response = await fetch(url.toString(), {
+          method: "POST",
+          headers,
+          body,
+          redirect: "manual",
+          signal: AbortSignal.timeout(this.requestTimeout)
+        });
+      } else {
+        for (const [key, value] of Object.entries(params)) {
+          url.searchParams.set(
+            key,
+            typeof value === "string" ? value : JSON.stringify(value)
+          );
+        }
+        response = await fetch(url.toString(), {
+          method: "GET",
+          headers,
+          redirect: "manual",
+          signal: AbortSignal.timeout(this.requestTimeout)
+        });
+      }
+      this._storeCookies(url.toString(), response.headers);
+      if (this.fatalStatusCodes.includes(response.status)) {
+        const redirect = response.headers.get("location") ? ` redirect to ${response.headers.get("location")}` : "";
+        throw new AbortDownloadException(
+          `Query to ${url} responded with "${response.status} ${response.statusText}"${redirect}`
+        );
+      }
+      if (response.status >= 300 && response.status < 400) {
+        const redirectUrl = response.headers.get("location");
+        if (redirectUrl) {
+          this.log(`
+HTTP redirect from ${url} to ${redirectUrl}`);
+          if (redirectUrl.startsWith("https://www.instagram.com/accounts/login") || redirectUrl.startsWith("https://i.instagram.com/accounts/login")) {
+            if (!this.is_logged_in) {
+              throw new LoginRequiredException(
+                "Redirected to login page. Use login() first."
+              );
+            }
+            throw new AbortDownloadException(
+              "Redirected to login page. You've been logged out, please wait some time, recreate the session and try again"
+            );
+          }
+        }
+      }
+      if (response.status === 400) {
+        let respJson2;
+        try {
+          respJson2 = await response.json();
+          const message = respJson2["message"];
+          if (message === "feedback_required" || message === "checkpoint_required" || message === "challenge_required") {
+            throw new AbortDownloadException(
+              this._responseError(response.status, response.statusText, url.toString(), respJson2)
+            );
+          }
+        } catch (e) {
+          if (e instanceof AbortDownloadException) throw e;
+        }
+        throw new QueryReturnedBadRequestException(
+          this._responseError(response.status, response.statusText, url.toString(), respJson2)
+        );
+      }
+      if (response.status === 404) {
+        throw new QueryReturnedNotFoundException(
+          this._responseError(response.status, response.statusText, url.toString())
+        );
+      }
+      if (response.status === 429) {
+        throw new TooManyRequestsException(
+          this._responseError(response.status, response.statusText, url.toString())
+        );
+      }
+      if (response.status !== 200) {
+        throw new ConnectionException(
+          this._responseError(response.status, response.statusText, url.toString())
+        );
+      }
+      const respJson = await response.json();
+      if ("status" in respJson && respJson["status"] !== "ok") {
+        throw new ConnectionException(
+          this._responseError(response.status, response.statusText, url.toString(), respJson)
+        );
+      }
+      return respJson;
+    } catch (err) {
+      const errorString = `JSON Query to ${path2}: ${err}`;
+      if (attempt >= this.maxConnectionAttempts) {
+        if (err instanceof QueryReturnedNotFoundException) {
+          throw new QueryReturnedNotFoundException(errorString);
+        }
+        throw new ConnectionException(errorString);
+      }
+      this.error(`${errorString} [retrying]`, false);
+      if (err instanceof TooManyRequestsException) {
+        if (isGraphqlQuery) {
+          await this._rateController.handle429(params["query_hash"]);
+        }
+        if (isDocIdQuery) {
+          await this._rateController.handle429(params["doc_id"]);
+        }
+        if (isIphoneQuery) {
+          await this._rateController.handle429("iphone");
+        }
+        if (isOtherQuery) {
+          await this._rateController.handle429("other");
+        }
+      }
+      return this.getJson(path2, params, {
+        host,
+        usePost,
+        attempt: attempt + 1,
+        ...extraHeaders !== void 0 && { headers: extraHeaders }
+      });
+    }
+  }
+  /**
+   * Do a GraphQL Query.
+   */
+  async graphql_query(queryHash, variables, referer) {
+    const headers = {
+      ...this._defaultHttpHeader(true),
+      authority: "www.instagram.com",
+      scheme: "https",
+      accept: "*/*"
+    };
+    delete headers["Connection"];
+    delete headers["Content-Length"];
+    if (referer) {
+      headers["referer"] = encodeURIComponent(referer);
+    }
+    const variablesJson = JSON.stringify(variables);
+    const respJson = await this.getJson(
+      "graphql/query",
+      { query_hash: queryHash, variables: variablesJson },
+      { headers }
+    );
+    if (!("status" in respJson)) {
+      this.error('GraphQL response did not contain a "status" field.');
+    }
+    return respJson;
+  }
+  /**
+   * Do a doc_id-based GraphQL Query using POST.
+   */
+  async doc_id_graphql_query(docId, variables, referer) {
+    const headers = {
+      ...this._defaultHttpHeader(true),
+      authority: "www.instagram.com",
+      scheme: "https",
+      accept: "*/*"
+    };
+    delete headers["Connection"];
+    delete headers["Content-Length"];
+    if (referer) {
+      headers["referer"] = encodeURIComponent(referer);
+    }
+    const variablesJson = JSON.stringify(variables);
+    const respJson = await this.getJson(
+      "graphql/query",
+      { variables: variablesJson, doc_id: docId, server_timestamps: "true" },
+      { usePost: true, headers }
+    );
+    if (!("status" in respJson)) {
+      this.error('GraphQL response did not contain a "status" field.');
+    }
+    return respJson;
+  }
+  /**
+   * JSON request to i.instagram.com.
+   */
+  async get_iphone_json(path2, params) {
+    const headers = {
+      ...this._iphoneHeaders,
+      "ig-intended-user-id": this._userId || "",
+      "x-pigeon-rawclienttime": (Date.now() / 1e3).toFixed(6)
+    };
+    const cookies = this.getCookies("https://i.instagram.com/");
+    const headerCookiesMapping = {
+      "x-mid": "mid",
+      "ig-u-ds-user-id": "ds_user_id",
+      "x-ig-device-id": "ig_did",
+      "x-ig-family-device-id": "ig_did",
+      family_device_id: "ig_did"
+    };
+    for (const [headerKey, cookieKey] of Object.entries(headerCookiesMapping)) {
+      if (cookieKey in cookies && !(headerKey in headers)) {
+        headers[headerKey] = cookies[cookieKey];
+      }
+    }
+    if ("rur" in cookies && !("ig-u-rur" in headers)) {
+      const rurValue = cookies["rur"];
+      headers["ig-u-rur"] = rurValue.replace(/^"|"$/g, "");
+    }
+    const response = await this.getJson(path2, params, {
+      host: "i.instagram.com",
+      headers
+    });
+    return response;
+  }
+  /**
+   * HEAD a URL anonymously.
+   */
+  async head(url, options = {}) {
+    const { allowRedirects = false } = options;
+    const response = await fetch(url, {
+      method: "HEAD",
+      redirect: allowRedirects ? "follow" : "manual",
+      headers: {
+        "User-Agent": this.userAgent
+      },
+      signal: AbortSignal.timeout(this.requestTimeout)
+    });
+    if (response.status === 200 || response.status >= 300 && response.status < 400) {
+      const headers = /* @__PURE__ */ new Map();
+      response.headers.forEach((value, key) => {
+        headers.set(key, value);
+      });
+      return { headers };
+    }
+    if (response.status === 403) {
+      throw new QueryReturnedForbiddenException(
+        this._responseError(response.status, response.statusText, url)
+      );
+    }
+    if (response.status === 404) {
+      throw new QueryReturnedNotFoundException(
+        this._responseError(response.status, response.statusText, url)
+      );
+    }
+    throw new ConnectionException(
+      this._responseError(response.status, response.statusText, url)
+    );
+  }
+  /**
+   * Test if logged in by querying the current user.
+   */
+  async testLogin() {
+    try {
+      const data = await this.graphql_query("d6f4427fbe92d846298cf93df0b937d3", {});
+      const userData = data["data"]?.["user"];
+      return userData ? userData["username"] : null;
+    } catch (err) {
+      if (err instanceof AbortDownloadException || err instanceof ConnectionException) {
+        this.error(`Error when checking if logged in: ${err}`);
+        return null;
+      }
+      throw err;
+    }
+  }
+  /**
+   * Login to Instagram.
+   */
+  async login(username, password) {
+    this._cookieJar = new CookieJar();
+    this._initAnonymousCookies();
+    const initUrl = "https://www.instagram.com/";
+    const initResponse = await fetch(initUrl, {
+      headers: {
+        "User-Agent": this.userAgent,
+        Cookie: this._getCookieHeader(initUrl)
+      },
+      signal: AbortSignal.timeout(this.requestTimeout)
+    });
+    this._storeCookies(initUrl, initResponse.headers);
+    const cookies = this.getCookies();
+    const csrfToken = cookies["csrftoken"];
+    if (!csrfToken) {
+      throw new LoginException("Failed to get CSRF token from Instagram.");
+    }
+    this._csrfToken = csrfToken;
+    await this.doSleep();
+    const encPassword = `#PWD_INSTAGRAM_BROWSER:0:${Math.floor(Date.now() / 1e3)}:${password}`;
+    const loginUrl = "https://www.instagram.com/api/v1/web/accounts/login/ajax/";
+    const loginResponse = await fetch(loginUrl, {
+      method: "POST",
+      headers: {
+        "User-Agent": this.userAgent,
+        "Content-Type": "application/x-www-form-urlencoded",
+        "X-CSRFToken": csrfToken,
+        Cookie: this._getCookieHeader(loginUrl),
+        Referer: "https://www.instagram.com/"
+      },
+      body: new URLSearchParams({
+        enc_password: encPassword,
+        username
+      }),
+      redirect: "follow",
+      signal: AbortSignal.timeout(this.requestTimeout)
+    });
+    this._storeCookies(loginUrl, loginResponse.headers);
+    let respJson;
+    try {
+      respJson = await loginResponse.json();
+    } catch {
+      throw new LoginException(
+        `Login error: JSON decode fail, ${loginResponse.status} - ${loginResponse.statusText}.`
+      );
+    }
+    if (respJson["two_factor_required"]) {
+      const twoFactorInfoResp = respJson["two_factor_info"];
+      const twoFactorId = twoFactorInfoResp["two_factor_identifier"];
+      this._twoFactorAuthPending = {
+        csrfToken,
+        cookies: this.getCookies(),
+        username,
+        twoFactorId
+      };
+      const twoFactorInfo = {
+        username,
+        identifier: twoFactorId
+      };
+      if (twoFactorInfoResp["obfuscated_phone_number"] !== void 0) {
+        twoFactorInfo.obfuscatedPhoneNumber = twoFactorInfoResp["obfuscated_phone_number"];
+      }
+      if (twoFactorInfoResp["show_messenger_code_option"] !== void 0) {
+        twoFactorInfo.showMessengerCodeOption = twoFactorInfoResp["show_messenger_code_option"];
+      }
+      if (twoFactorInfoResp["show_new_login_screen"] !== void 0) {
+        twoFactorInfo.showNewLoginScreen = twoFactorInfoResp["show_new_login_screen"];
+      }
+      if (twoFactorInfoResp["show_trusted_device_option"] !== void 0) {
+        twoFactorInfo.showTrustedDeviceOption = twoFactorInfoResp["show_trusted_device_option"];
+      }
+      if (twoFactorInfoResp["pending_trusted_notification_polling"] !== void 0) {
+        twoFactorInfo.pendingTrustedNotificationPolling = twoFactorInfoResp["pending_trusted_notification_polling"];
+      }
+      throw new TwoFactorAuthRequiredException(
+        twoFactorInfo,
+        "Login error: two-factor authentication required."
+      );
+    }
+    if (respJson["checkpoint_url"]) {
+      throw new LoginException(
+        `Login: Checkpoint required. Point your browser to ${respJson["checkpoint_url"]} - follow the instructions, then retry.`
+      );
+    }
+    if (respJson["status"] !== "ok") {
+      const message = respJson["message"];
+      if (message) {
+        throw new LoginException(
+          `Login error: "${respJson["status"]}" status, message "${message}".`
+        );
+      }
+      throw new LoginException(`Login error: "${respJson["status"]}" status.`);
+    }
+    if (!("authenticated" in respJson)) {
+      const message = respJson["message"];
+      if (message) {
+        throw new LoginException(`Login error: Unexpected response, "${message}".`);
+      }
+      throw new LoginException(
+        "Login error: Unexpected response, this might indicate a blocked IP."
+      );
+    }
+    if (!respJson["authenticated"]) {
+      if (respJson["user"]) {
+        throw new BadCredentialsException("Login error: Wrong password.");
+      }
+      throw new LoginException(`Login error: User ${username} does not exist.`);
+    }
+    const newCookies = this.getCookies();
+    this._csrfToken = newCookies["csrftoken"] || csrfToken;
+    this._username = username;
+    this._userId = respJson["userId"] || newCookies["ds_user_id"] || null;
+  }
+  /**
+   * Second step of login if 2FA is enabled.
+   */
+  async twoFactorLogin(twoFactorCode) {
+    if (!this._twoFactorAuthPending) {
+      throw new InvalidArgumentException("No two-factor authentication pending.");
+    }
+    const { csrfToken, cookies, username, twoFactorId } = this._twoFactorAuthPending;
+    this._cookieJar = new CookieJar();
+    this.setCookies(cookies);
+    const loginUrl = "https://www.instagram.com/accounts/login/ajax/two_factor/";
+    const response = await fetch(loginUrl, {
+      method: "POST",
+      headers: {
+        "User-Agent": this.userAgent,
+        "Content-Type": "application/x-www-form-urlencoded",
+        "X-CSRFToken": csrfToken,
+        Cookie: this._getCookieHeader(loginUrl),
+        Referer: "https://www.instagram.com/"
+      },
+      body: new URLSearchParams({
+        username,
+        verificationCode: twoFactorCode,
+        identifier: twoFactorId
+      }),
+      redirect: "follow",
+      signal: AbortSignal.timeout(this.requestTimeout)
+    });
+    this._storeCookies(loginUrl, response.headers);
+    const respJson = await response.json();
+    if (respJson["status"] !== "ok") {
+      const message = respJson["message"];
+      if (message) {
+        throw new BadCredentialsException(`2FA error: ${message}`);
+      }
+      throw new BadCredentialsException(`2FA error: "${respJson["status"]}" status.`);
+    }
+    const newCookies = this.getCookies();
+    this._csrfToken = newCookies["csrftoken"] || csrfToken;
+    this._username = username;
+    this._userId = newCookies["ds_user_id"] || null;
+    this._twoFactorAuthPending = null;
+  }
+};
+
+// src/nodeiterator.ts
+import { createHash } from "crypto";
+var FrozenNodeIterator = class _FrozenNodeIterator {
+  queryHash;
+  queryVariables;
+  queryReferer;
+  contextUsername;
+  totalIndex;
+  bestBefore;
+  remainingData;
+  firstNode;
+  docId;
+  constructor(params) {
+    this.queryHash = params.queryHash;
+    this.queryVariables = params.queryVariables;
+    this.queryReferer = params.queryReferer;
+    this.contextUsername = params.contextUsername;
+    this.totalIndex = params.totalIndex;
+    this.bestBefore = params.bestBefore;
+    this.remainingData = params.remainingData;
+    this.firstNode = params.firstNode;
+    this.docId = params.docId;
+  }
+  /**
+   * Convert to plain object for JSON serialization.
+   */
+  toObject() {
+    return {
+      queryHash: this.queryHash,
+      queryVariables: this.queryVariables,
+      queryReferer: this.queryReferer,
+      contextUsername: this.contextUsername,
+      totalIndex: this.totalIndex,
+      bestBefore: this.bestBefore,
+      remainingData: this.remainingData,
+      firstNode: this.firstNode,
+      docId: this.docId
+    };
+  }
+  /**
+   * Create from plain object (JSON deserialization).
+   */
+  static fromObject(obj) {
+    return new _FrozenNodeIterator(obj);
+  }
+};
+var NodeIterator = class _NodeIterator {
+  static _graphql_page_length = 12;
+  static _shelf_life_days = 29;
+  _context;
+  _queryHash;
+  _docId;
+  _edgeExtractor;
+  _nodeWrapper;
+  _queryVariables;
+  _queryReferer;
+  _isFirst;
+  _pageIndex = 0;
+  _totalIndex = 0;
+  _data = null;
+  _bestBefore = null;
+  _firstNode = null;
+  _initialized = false;
+  _initPromise = null;
+  constructor(options) {
+    this._context = options.context;
+    this._queryHash = options.queryHash;
+    this._docId = options.docId;
+    this._edgeExtractor = options.edgeExtractor;
+    this._nodeWrapper = options.nodeWrapper;
+    this._queryVariables = options.queryVariables ?? {};
+    this._queryReferer = options.queryReferer ?? null;
+    this._isFirst = options.isFirst;
+    if (options.firstData !== void 0) {
+      this._data = options.firstData;
+      this._bestBefore = new Date(Date.now() + _NodeIterator._shelf_life_days * 24 * 60 * 60 * 1e3);
+      this._initialized = true;
+    } else {
+      this._initPromise = this._initialize();
+    }
+  }
+  async _initialize() {
+    if (this._initialized) return;
+    this._data = await this._query();
+    this._initialized = true;
+  }
+  async _ensureInitialized() {
+    if (!this._initialized && this._initPromise) {
+      await this._initPromise;
+    }
+  }
+  async _query(after) {
+    if (this._docId !== void 0) {
+      return this._queryDocId(this._docId, after);
+    } else {
+      if (this._queryHash === null) {
+        throw new Error("Either queryHash or docId must be provided");
+      }
+      return this._queryQueryHash(this._queryHash, after);
+    }
+  }
+  async _queryDocId(docId, after) {
+    const paginationVariables = {
+      __relay_internal__pv__PolarisFeedShareMenurelayprovider: false
+    };
+    if (after !== void 0) {
+      paginationVariables["after"] = after;
+      paginationVariables["before"] = null;
+      paginationVariables["first"] = 12;
+      paginationVariables["last"] = null;
+    }
+    const response = await this._context.doc_id_graphql_query(
+      docId,
+      { ...this._queryVariables, ...paginationVariables },
+      this._queryReferer ?? void 0
+    );
+    const data = this._edgeExtractor(response);
+    this._bestBefore = new Date(Date.now() + _NodeIterator._shelf_life_days * 24 * 60 * 60 * 1e3);
+    return data;
+  }
+  async _queryQueryHash(queryHash, after) {
+    const paginationVariables = {
+      first: _NodeIterator._graphql_page_length
+    };
+    if (after !== void 0) {
+      paginationVariables["after"] = after;
+    }
+    const response = await this._context.graphql_query(
+      queryHash,
+      { ...this._queryVariables, ...paginationVariables },
+      this._queryReferer ?? void 0
+    );
+    const data = this._edgeExtractor(response);
+    this._bestBefore = new Date(Date.now() + _NodeIterator._shelf_life_days * 24 * 60 * 60 * 1e3);
+    return data;
+  }
+  /**
+   * The count as returned by Instagram.
+   * This is not always the total count this iterator will yield.
+   */
+  get count() {
+    return this._data?.count;
+  }
+  /**
+   * Number of items that have already been returned.
+   */
+  get totalIndex() {
+    return this._totalIndex;
+  }
+  /**
+   * Magic string for easily identifying a matching iterator file for resuming.
+   * Two NodeIterators are matching if and only if they have the same magic.
+   */
+  get magic() {
+    const data = JSON.stringify([
+      this._queryHash,
+      this._queryVariables,
+      this._queryReferer,
+      this._context.username
+    ]);
+    const hash = createHash("sha256").update(data).digest();
+    return hash.subarray(0, 6).toString("base64url");
+  }
+  /**
+   * If this iterator has produced any items, returns the first item produced.
+   *
+   * It is possible to override what is considered the first item by passing
+   * a callback function as the `isFirst` parameter when creating the class.
+   */
+  get firstItem() {
+    return this._firstNode !== null ? this._nodeWrapper(this._firstNode) : null;
+  }
+  /**
+   * Static page length used for pagination.
+   */
+  static pageLength() {
+    return _NodeIterator._graphql_page_length;
+  }
+  /**
+   * Freeze the iterator for later resuming.
+   */
+  freeze() {
+    let remainingData = null;
+    if (this._data !== null) {
+      remainingData = {
+        ...this._data,
+        edges: this._data.edges.slice(Math.max(this._pageIndex - 1, 0))
+      };
+    }
+    return new FrozenNodeIterator({
+      queryHash: this._queryHash,
+      queryVariables: this._queryVariables,
+      queryReferer: this._queryReferer,
+      contextUsername: this._context.username,
+      totalIndex: Math.max(this._totalIndex - 1, 0),
+      bestBefore: this._bestBefore ? this._bestBefore.getTime() / 1e3 : null,
+      remainingData,
+      firstNode: this._firstNode,
+      docId: this._docId
+    });
+  }
+  /**
+   * Use this iterator for resuming from earlier iteration.
+   *
+   * @throws InvalidArgumentException if the iterator has already been used or the frozen state doesn't match
+   */
+  thaw(frozen) {
+    if (this._totalIndex || this._pageIndex) {
+      throw new InvalidArgumentException("thaw() called on already-used iterator.");
+    }
+    if (this._queryHash !== frozen.queryHash || JSON.stringify(this._queryVariables) !== JSON.stringify(frozen.queryVariables) || this._queryReferer !== frozen.queryReferer || this._context.username !== frozen.contextUsername || this._docId !== frozen.docId) {
+      throw new InvalidArgumentException("Mismatching resume information.");
+    }
+    if (!frozen.bestBefore) {
+      throw new InvalidArgumentException('"best before" date missing.');
+    }
+    if (frozen.remainingData === null) {
+      throw new InvalidArgumentException('"remaining_data" missing.');
+    }
+    this._totalIndex = frozen.totalIndex;
+    this._bestBefore = new Date(frozen.bestBefore * 1e3);
+    this._data = frozen.remainingData;
+    this._initialized = true;
+    if (frozen.firstNode !== null) {
+      this._firstNode = frozen.firstNode;
+    }
+  }
+  /**
+   * Async iterator implementation.
+   */
+  async *[Symbol.asyncIterator]() {
+    await this._ensureInitialized();
+    while (true) {
+      if (this._data === null) {
+        return;
+      }
+      while (this._pageIndex < this._data.edges.length) {
+        const edge = this._data.edges[this._pageIndex];
+        if (!edge) break;
+        const node = edge.node;
+        this._pageIndex += 1;
+        this._totalIndex += 1;
+        const item = this._nodeWrapper(node);
+        if (this._isFirst !== void 0) {
+          if (this._isFirst(item, this.firstItem)) {
+            this._firstNode = node;
+          }
+        } else {
+          if (this._firstNode === null) {
+            this._firstNode = node;
+          }
+        }
+        yield item;
+      }
+      if (this._data.page_info?.has_next_page && this._data.page_info.end_cursor) {
+        const queryResponse = await this._query(this._data.page_info.end_cursor);
+        if (JSON.stringify(this._data.edges) !== JSON.stringify(queryResponse.edges) && queryResponse.edges.length > 0) {
+          this._pageIndex = 0;
+          this._data = queryResponse;
+          continue;
+        }
+      }
+      return;
+    }
+  }
+};
+async function resumableIteration(options) {
+  const { context, iterator, load, save: _save, formatPath, checkBbd = true, enabled = true } = options;
+  if (!enabled || !(iterator instanceof NodeIterator)) {
+    return { isResuming: false, startIndex: 0 };
+  }
+  const nodeIterator = iterator;
+  let isResuming = false;
+  let startIndex = 0;
+  const resumeFilePath = formatPath(nodeIterator.magic);
+  try {
+    const fni = await Promise.resolve(load(context, resumeFilePath));
+    if (!(fni instanceof FrozenNodeIterator)) {
+      throw new InvalidArgumentException("Invalid type.");
+    }
+    if (checkBbd && fni.bestBefore && new Date(fni.bestBefore * 1e3) < /* @__PURE__ */ new Date()) {
+      throw new InvalidArgumentException('"Best before" date exceeded.');
+    }
+    nodeIterator.thaw(fni);
+    isResuming = true;
+    startIndex = nodeIterator.totalIndex;
+    context.log(`Resuming from ${resumeFilePath}.`);
+  } catch (e) {
+    if (e instanceof InvalidArgumentException) {
+      context.error(`Warning: Not resuming from ${resumeFilePath}: ${e.message}`);
+    }
+  }
+  return { isResuming, startIndex };
+}
+
+// src/structures.ts
+var HASHTAG_REGEX = /(?:#)(\w{1,150})/g;
+var MENTION_REGEX = /(?:^|[^\w\n]|_)(?:@)(\w(?:(?:\w|(?:\.(?!\.))){0,28}(?:\w))?)/g;
+function optionalNormalize(str) {
+  if (str != null) {
+    return str.normalize("NFC");
+  }
+  return null;
+}
+function shortcodeToMediaid(code) {
+  if (code.length > 11) {
+    throw new InvalidArgumentException(
+      `Wrong shortcode "${code}", unable to convert to mediaid.`
+    );
+  }
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  let mediaid = BigInt(0);
+  for (const char of code) {
+    mediaid = mediaid * BigInt(64) + BigInt(alphabet.indexOf(char));
+  }
+  return mediaid;
+}
+function mediaidToShortcode(mediaid) {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  let shortcode = "";
+  let id = mediaid;
+  while (id > 0) {
+    shortcode = alphabet[Number(id % BigInt(64))] + shortcode;
+    id = id / BigInt(64);
+  }
+  return shortcode || "A";
+}
+function extractHashtags(text) {
+  const matches = [];
+  let match;
+  const regex = new RegExp(HASHTAG_REGEX.source, "g");
+  while ((match = regex.exec(text.toLowerCase())) !== null) {
+    matches.push(match[1]);
+  }
+  return matches;
+}
+function extractMentions(text) {
+  const matches = [];
+  let match;
+  const regex = new RegExp(MENTION_REGEX.source, "g");
+  while ((match = regex.exec(text.toLowerCase())) !== null) {
+    matches.push(match[1]);
+  }
+  return matches;
+}
+function ellipsifyCaption(caption) {
+  const pcaption = caption.split("\n").filter((s) => s).map((s) => s.replace(/\//g, "\u2215")).join(" ").trim();
+  return pcaption.length > 31 ? pcaption.slice(0, 30) + "\u2026" : pcaption;
+}
+var PostComment = class _PostComment {
+  _context;
+  _node;
+  _answers;
+  _post;
+  constructor(context, node, answers, post) {
+    this._context = context;
+    this._node = node;
+    this._answers = answers;
+    this._post = post;
+  }
+  /**
+   * Create a PostComment from an iPhone API struct.
+   */
+  static fromIphoneStruct(context, media, answers, post) {
+    return new _PostComment(
+      context,
+      {
+        id: media["pk"],
+        created_at: media["created_at"],
+        text: media["text"],
+        edge_liked_by: {
+          count: media["comment_like_count"]
+        },
+        iphone_struct: media
+      },
+      answers,
+      post
+    );
+  }
+  /** ID number of comment. */
+  get id() {
+    return this._node["id"];
+  }
+  /** Timestamp when comment was created (UTC). */
+  get created_at_utc() {
+    return new Date(this._node["created_at"] * 1e3);
+  }
+  /** Comment text. */
+  get text() {
+    return this._node["text"];
+  }
+  /** Owner Profile of the comment. */
+  get owner() {
+    if ("iphone_struct" in this._node) {
+      const iphoneStruct = this._node["iphone_struct"];
+      return Profile.fromIphoneStruct(
+        this._context,
+        iphoneStruct["user"]
+      );
+    }
+    return new Profile(this._context, this._node["owner"]);
+  }
+  /** Number of likes on comment. */
+  get likes_count() {
+    const edgeLikedBy = this._node["edge_liked_by"];
+    return edgeLikedBy?.["count"] ?? 0;
+  }
+  /** Iterator which yields all PostCommentAnswer for the comment. */
+  get answers() {
+    return this._answers;
+  }
+  toString() {
+    return `<PostComment ${this.id} of ${this._post.shortcode}>`;
+  }
+};
+var Post = class _Post {
+  _context;
+  _node;
+  _owner_profile;
+  _full_metadata_dict = null;
+  _location = null;
+  _iphone_struct_ = null;
+  /**
+   * @param context InstaloaderContext used for additional queries if necessary.
+   * @param node Node structure, as returned by Instagram.
+   * @param owner_profile The Profile of the owner, if already known at creation.
+   */
+  constructor(context, node, owner_profile = null) {
+    if (!("shortcode" in node) && !("code" in node)) {
+      throw new Error("Node must contain 'shortcode' or 'code'");
+    }
+    this._context = context;
+    this._node = node;
+    this._owner_profile = owner_profile;
+    if ("iphone_struct" in node) {
+      this._iphone_struct_ = node["iphone_struct"];
+    }
+  }
+  /**
+   * Create a post object from a given shortcode.
+   */
+  static async fromShortcode(context, shortcode) {
+    const post = new _Post(context, { shortcode });
+    post._node = await post._getFullMetadata();
+    return post;
+  }
+  /**
+   * Create a post object from a given mediaid.
+   */
+  static async fromMediaid(context, mediaid) {
+    return _Post.fromShortcode(context, mediaidToShortcode(mediaid));
+  }
+  /**
+   * Create a post from a given iphone_struct.
+   */
+  static fromIphoneStruct(context, media) {
+    const mediaTypes = {
+      1: "GraphImage",
+      2: "GraphVideo",
+      8: "GraphSidecar"
+    };
+    const mediaType = media["media_type"];
+    const typename = mediaTypes[mediaType] ?? "GraphImage";
+    const caption = media["caption"];
+    const fakeNode = {
+      shortcode: media["code"],
+      id: media["pk"],
+      __typename: typename,
+      is_video: typename === "GraphVideo",
+      date: media["taken_at"],
+      caption: caption?.["text"] ?? null,
+      title: media["title"] ?? null,
+      viewer_has_liked: media["has_liked"],
+      edge_media_preview_like: { count: media["like_count"] },
+      accessibility_caption: media["accessibility_caption"] ?? null,
+      comments: media["comment_count"] ?? 0,
+      iphone_struct: media
+    };
+    try {
+      const imageVersions = media["image_versions2"];
+      const candidates = imageVersions?.["candidates"];
+      if (candidates && candidates.length > 0) {
+        const firstCandidate = candidates[0];
+        fakeNode["display_url"] = firstCandidate["url"];
+      }
+    } catch {
+    }
+    try {
+      const videoVersions = media["video_versions"];
+      if (videoVersions && videoVersions.length > 0) {
+        const lastVideo = videoVersions[videoVersions.length - 1];
+        fakeNode["video_url"] = lastVideo["url"];
+        fakeNode["video_duration"] = media["video_duration"];
+        fakeNode["video_view_count"] = media["view_count"];
+      }
+    } catch {
+    }
+    try {
+      const carouselMedia = media["carousel_media"];
+      if (carouselMedia) {
+        fakeNode["edge_sidecar_to_children"] = {
+          edges: carouselMedia.map(
+            (node) => ({ node: _Post._convertIphoneCarousel(node, mediaTypes) })
+          )
+        };
+      }
+    } catch {
+    }
+    const ownerProfile = "user" in media ? Profile.fromIphoneStruct(context, media["user"]) : null;
+    return new _Post(context, fakeNode, ownerProfile);
+  }
+  static _convertIphoneCarousel(iphoneNode, mediaTypes) {
+    const mediaType = iphoneNode["media_type"];
+    const imageVersions = iphoneNode["image_versions2"];
+    const candidates = imageVersions["candidates"];
+    const firstCandidate = candidates[0];
+    const fakeNode = {
+      display_url: firstCandidate["url"],
+      is_video: mediaTypes[mediaType] === "GraphVideo"
+    };
+    const videoVersions = iphoneNode["video_versions"];
+    if (videoVersions && videoVersions.length > 0) {
+      const firstVideo = videoVersions[0];
+      fakeNode["video_url"] = firstVideo["url"];
+    }
+    return fakeNode;
+  }
+  /** The values of __typename fields that the Post class can handle. */
+  static supportedGraphqlTypes() {
+    return ["GraphImage", "GraphVideo", "GraphSidecar"];
+  }
+  /** Media shortcode. URL of the post is instagram.com/p/<shortcode>/. */
+  get shortcode() {
+    return this._node["shortcode"] ?? this._node["code"];
+  }
+  /** The mediaid is a decimal representation of the media shortcode. */
+  get mediaid() {
+    return BigInt(this._node["id"]);
+  }
+  /** Title of post */
+  get title() {
+    try {
+      return this._field("title");
+    } catch {
+      return null;
+    }
+  }
+  toString() {
+    return `<Post ${this.shortcode}>`;
+  }
+  equals(other) {
+    return this.shortcode === other.shortcode;
+  }
+  async _obtainMetadata() {
+    if (!this._full_metadata_dict) {
+      const result = await this._context.doc_id_graphql_query(
+        "8845758582119845",
+        { shortcode: this.shortcode }
+      );
+      const data = result["data"];
+      const picJson = data["xdt_shortcode_media"];
+      if (picJson === null) {
+        throw new BadResponseException("Fetching Post metadata failed.");
+      }
+      const xdtTypes = {
+        XDTGraphImage: "GraphImage",
+        XDTGraphVideo: "GraphVideo",
+        XDTGraphSidecar: "GraphSidecar"
+      };
+      const typename = picJson["__typename"];
+      if (!(typename in xdtTypes)) {
+        throw new BadResponseException(
+          `Unknown __typename in metadata: ${typename}.`
+        );
+      }
+      picJson["__typename"] = xdtTypes[typename];
+      this._full_metadata_dict = picJson;
+      if (this.shortcode !== this._full_metadata_dict["shortcode"]) {
+        Object.assign(this._node, this._full_metadata_dict);
+        throw new PostChangedException();
+      }
+    }
+  }
+  async _getFullMetadata() {
+    await this._obtainMetadata();
+    return this._full_metadata_dict;
+  }
+  /**
+   * Get iPhone struct for high quality media.
+   * Reserved for future use to fetch HQ images.
+   */
+  // @ts-expect-error Reserved for future HQ image fetching
+  async _getIphoneStruct() {
+    if (!this._context.iphoneSupport) {
+      throw new IPhoneSupportDisabledException("iPhone support is disabled.");
+    }
+    if (!this._context.is_logged_in) {
+      throw new LoginRequiredException(
+        "Login required to access iPhone media info endpoint."
+      );
+    }
+    if (!this._iphone_struct_) {
+      const data = await this._context.get_iphone_json(
+        `api/v1/media/${this.mediaid}/info/`,
+        {}
+      );
+      const items = data["items"];
+      this._iphone_struct_ = items[0];
+    }
+    return this._iphone_struct_;
+  }
+  /**
+   * Lookup fields in _node, and if not found in _full_metadata.
+   * Throws if not found anywhere.
+   */
+  _field(...keys) {
+    try {
+      let d = this._node;
+      for (const key of keys) {
+        if (typeof d !== "object" || d === null || Array.isArray(d)) {
+          throw new Error("Key not found");
+        }
+        d = d[key];
+        if (d === void 0) {
+          throw new Error("Key not found");
+        }
+      }
+      return d;
+    } catch {
+      throw new Error(
+        `Field ${keys.join(".")} not found. Use async method for full metadata.`
+      );
+    }
+  }
+  /**
+   * Async version of _field that can fetch full metadata if needed.
+   */
+  async getField(...keys) {
+    try {
+      let d = this._node;
+      for (const key of keys) {
+        if (typeof d !== "object" || d === null || Array.isArray(d)) {
+          throw new Error("Key not found");
+        }
+        d = d[key];
+        if (d === void 0) {
+          throw new Error("Key not found");
+        }
+      }
+      return d;
+    } catch {
+      const fullMetadata = await this._getFullMetadata();
+      let d = fullMetadata;
+      for (const key of keys) {
+        if (typeof d !== "object" || d === null || Array.isArray(d)) {
+          throw new Error("Key not found");
+        }
+        d = d[key];
+        if (d === void 0) {
+          throw new Error("Key not found");
+        }
+      }
+      return d;
+    }
+  }
+  /** Profile instance of the Post's owner. */
+  async getOwnerProfile() {
+    if (!this._owner_profile) {
+      const owner = this._node["owner"];
+      if (owner && "username" in owner) {
+        this._owner_profile = new Profile(this._context, owner);
+      } else {
+        const fullMetadata = await this._getFullMetadata();
+        const ownerStruct = fullMetadata["owner"];
+        this._owner_profile = new Profile(this._context, ownerStruct);
+      }
+    }
+    return this._owner_profile;
+  }
+  /** The Post's lowercase owner name. */
+  async getOwnerUsername() {
+    return (await this.getOwnerProfile()).username;
+  }
+  /** The ID of the Post's owner. */
+  get owner_id() {
+    const owner = this._node["owner"];
+    if (owner && "id" in owner) {
+      return Number(owner["id"]);
+    }
+    return null;
+  }
+  /** Timestamp when the post was created (local time zone). */
+  get date_local() {
+    return new Date(this._getTimestampDateCreated() * 1e3);
+  }
+  /** Timestamp when the post was created (UTC). */
+  get date_utc() {
+    return new Date(this._getTimestampDateCreated() * 1e3);
+  }
+  /** Synonym to date_utc */
+  get date() {
+    return this.date_utc;
+  }
+  _getTimestampDateCreated() {
+    return this._node["date"] ?? this._node["taken_at_timestamp"];
+  }
+  /** URL of the picture / video thumbnail of the post */
+  get url() {
+    return this._node["display_url"] ?? this._node["display_src"];
+  }
+  /** Type of post: GraphImage, GraphVideo or GraphSidecar */
+  get typename() {
+    return this._field("__typename");
+  }
+  /** The number of media in a sidecar Post, or 1 if not a sidecar. */
+  get mediacount() {
+    if (this.typename === "GraphSidecar") {
+      try {
+        const edges = this._field(
+          "edge_sidecar_to_children",
+          "edges"
+        );
+        return edges.length;
+      } catch {
+        return 1;
+      }
+    }
+    return 1;
+  }
+  /** Caption. */
+  get caption() {
+    const edgeMediaToCaption = this._node["edge_media_to_caption"];
+    if (edgeMediaToCaption) {
+      const edges = edgeMediaToCaption["edges"];
+      if (edges && edges.length > 0) {
+        const firstEdge = edges[0];
+        const node = firstEdge["node"];
+        return optionalNormalize(node["text"]);
+      }
+    }
+    if ("caption" in this._node) {
+      return optionalNormalize(this._node["caption"]);
+    }
+    return null;
+  }
+  /** List of all lowercased hashtags (without preceding #) that occur in the Post's caption. */
+  get caption_hashtags() {
+    if (!this.caption) {
+      return [];
+    }
+    return extractHashtags(this.caption);
+  }
+  /** List of all lowercased profiles that are mentioned in the Post's caption, without preceding @. */
+  get caption_mentions() {
+    if (!this.caption) {
+      return [];
+    }
+    return extractMentions(this.caption);
+  }
+  /** Printable caption, useful as a format specifier for --filename-pattern. */
+  get pcaption() {
+    return this.caption ? ellipsifyCaption(this.caption) : "";
+  }
+  /** Accessibility caption of the post, if available. */
+  get accessibility_caption() {
+    try {
+      return this._field("accessibility_caption");
+    } catch {
+      return null;
+    }
+  }
+  /** List of all lowercased users that are tagged in the Post. */
+  get tagged_users() {
+    try {
+      const edges = this._field(
+        "edge_media_to_tagged_user",
+        "edges"
+      );
+      return edges.map((edge) => {
+        const e = edge;
+        const node = e["node"];
+        const user = node["user"];
+        return user["username"].toLowerCase();
+      });
+    } catch {
+      return [];
+    }
+  }
+  /** True if the Post is a video. */
+  get is_video() {
+    return this._node["is_video"];
+  }
+  /** URL of the video, or null. */
+  get video_url() {
+    if (this.is_video) {
+      try {
+        return this._field("video_url");
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  /** View count of the video, or null. */
+  get video_view_count() {
+    if (this.is_video) {
+      try {
+        return this._field("video_view_count");
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  /** Duration of the video in seconds, or null. */
+  get video_duration() {
+    if (this.is_video) {
+      try {
+        return this._field("video_duration");
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  /** Whether the viewer has liked the post, or null if not logged in. */
+  get viewer_has_liked() {
+    if (!this._context.is_logged_in) {
+      return null;
+    }
+    const likes = this._node["likes"];
+    if (likes && "viewer_has_liked" in likes) {
+      return likes["viewer_has_liked"];
+    }
+    try {
+      return this._field("viewer_has_liked");
+    } catch {
+      return null;
+    }
+  }
+  /** Likes count */
+  get likes() {
+    try {
+      return this._field("edge_media_preview_like", "count");
+    } catch {
+      return 0;
+    }
+  }
+  /** Comment count including answers */
+  get comments() {
+    const edgeMediaToComment = this._node["edge_media_to_comment"];
+    if (edgeMediaToComment && "count" in edgeMediaToComment) {
+      return edgeMediaToComment["count"];
+    }
+    try {
+      return this._field("edge_media_to_parent_comment", "count");
+    } catch {
+      try {
+        return this._field("edge_media_to_comment", "count");
+      } catch {
+        return 0;
+      }
+    }
+  }
+  /** Whether Post is a sponsored post. */
+  get is_sponsored() {
+    try {
+      const sponsorEdges = this._field(
+        "edge_media_to_sponsor_user",
+        "edges"
+      );
+      return sponsorEdges.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  /** Returns true if is_video for each media in sidecar. */
+  getIsVideos() {
+    if (this.typename === "GraphSidecar") {
+      try {
+        const edges = this._field(
+          "edge_sidecar_to_children",
+          "edges"
+        );
+        return edges.map((edge) => {
+          const e = edge;
+          const node = e["node"];
+          return node["is_video"];
+        });
+      } catch {
+        return [this.is_video];
+      }
+    }
+    return [this.is_video];
+  }
+  /** Sidecar nodes of a Post with typename==GraphSidecar. */
+  *getSidecarNodes(start = 0, end = -1) {
+    if (this.typename !== "GraphSidecar") {
+      return;
+    }
+    try {
+      const edges = this._field(
+        "edge_sidecar_to_children",
+        "edges"
+      );
+      const actualEnd = end < 0 ? edges.length - 1 : end;
+      const actualStart = start < 0 ? edges.length - 1 : start;
+      for (let idx = 0; idx < edges.length; idx++) {
+        if (idx >= actualStart && idx <= actualEnd) {
+          const edge = edges[idx];
+          const node = edge["node"];
+          const isVideo = node["is_video"];
+          const displayUrl = node["display_url"];
+          const videoUrl = isVideo ? node["video_url"] : null;
+          yield {
+            is_video: isVideo,
+            display_url: displayUrl,
+            video_url: videoUrl
+          };
+        }
+      }
+    } catch {
+    }
+  }
+  /** Returns Post as a JSON-serializable object. */
+  toJSON() {
+    const node = { ...this._node };
+    if (this._full_metadata_dict) {
+      Object.assign(node, this._full_metadata_dict);
+    }
+    if (this._location) {
+      node["location"] = this._location;
+    }
+    if (this._iphone_struct_) {
+      node["iphone_struct"] = this._iphone_struct_;
+    }
+    return node;
+  }
+};
+var Profile = class _Profile {
+  _context;
+  _node;
+  // Reserved for future has_public_story implementation
+  // @ts-expect-error Reserved for future use
+  _has_public_story = null;
+  _has_full_metadata = false;
+  _iphone_struct_ = null;
+  constructor(context, node) {
+    if (!("username" in node)) {
+      throw new Error("Node must contain 'username'");
+    }
+    this._context = context;
+    this._node = node;
+    if ("iphone_struct" in node) {
+      this._iphone_struct_ = node["iphone_struct"];
+    }
+  }
+  /**
+   * Create a Profile instance from a given username.
+   * Raises exception if it does not exist.
+   */
+  static async fromUsername(context, username) {
+    const profile = new _Profile(context, { username: username.toLowerCase() });
+    await profile._obtainMetadata();
+    return profile;
+  }
+  /**
+   * Create a Profile instance from a given userid.
+   * If possible, use fromUsername or constructor instead.
+   */
+  static async fromId(context, profileId) {
+    const cached = context.profile_id_cache.get(profileId);
+    if (cached) {
+      return cached;
+    }
+    const data = await context.graphql_query("7c16654f22c819fb63d1183034a5162f", {
+      user_id: String(profileId),
+      include_chaining: false,
+      include_reel: true,
+      include_suggested_users: false,
+      include_logged_out_extras: false,
+      include_highlight_reels: false
+    });
+    const userData = data["data"]["user"];
+    if (userData) {
+      const reel = userData["reel"];
+      const owner = reel["owner"];
+      const profile = new _Profile(context, owner);
+      context.profile_id_cache.set(profileId, profile);
+      return profile;
+    }
+    throw new ProfileNotExistsException(
+      `No profile found, the user may have blocked you (ID: ${profileId}).`
+    );
+  }
+  /**
+   * Create a profile from a given iphone_struct.
+   */
+  static fromIphoneStruct(context, media) {
+    return new _Profile(context, {
+      id: media["pk"],
+      username: media["username"],
+      is_private: media["is_private"],
+      full_name: media["full_name"],
+      profile_pic_url_hd: media["profile_pic_url"],
+      iphone_struct: media
+    });
+  }
+  /**
+   * Return own profile if logged-in.
+   */
+  static async ownProfile(context) {
+    if (!context.is_logged_in) {
+      throw new LoginRequiredException("Login required to access own profile.");
+    }
+    const data = await context.graphql_query("d6f4427fbe92d846298cf93df0b937d3", {});
+    const userData = data["data"]["user"];
+    return new _Profile(context, userData);
+  }
+  async _obtainMetadata() {
+    try {
+      if (!this._has_full_metadata) {
+        const metadata = await this._context.get_iphone_json(
+          `api/v1/users/web_profile_info/?username=${this.username}`,
+          {}
+        );
+        const data = metadata["data"];
+        const user = data["user"];
+        if (user === null) {
+          throw new ProfileNotExistsException(
+            `Profile ${this.username} does not exist.`
+          );
+        }
+        this._node = user;
+        this._has_full_metadata = true;
+      }
+    } catch (err) {
+      if (err instanceof QueryReturnedNotFoundException || err instanceof TypeError) {
+        const topSearch = new TopSearchResults(this._context, this.username);
+        const profiles = [];
+        for await (const profile of topSearch.getProfiles()) {
+          profiles.push(profile.username);
+          if (profiles.length >= 5) break;
+        }
+        if (profiles.length > 0) {
+          if (profiles.includes(this.username)) {
+            throw new ProfileNotExistsException(
+              `Profile ${this.username} seems to exist, but could not be loaded.`
+            );
+          }
+          const plural = profiles.length > 1 ? "s are" : " is";
+          throw new ProfileNotExistsException(
+            `Profile ${this.username} does not exist.
+The most similar profile${plural}: ${profiles.slice(0, 5).join(", ")}.`
+          );
+        }
+        throw new ProfileNotExistsException(
+          `Profile ${this.username} does not exist.`
+        );
+      }
+      throw err;
+    }
+  }
+  _metadata(...keys) {
+    let d = this._node;
+    for (const key of keys) {
+      if (typeof d !== "object" || d === null || Array.isArray(d)) {
+        throw new Error("Key not found");
+      }
+      d = d[key];
+      if (d === void 0) {
+        throw new Error("Key not found");
+      }
+    }
+    return d;
+  }
+  /**
+   * Async version that can fetch full metadata if needed.
+   */
+  async getMetadata(...keys) {
+    try {
+      return this._metadata(...keys);
+    } catch {
+      await this._obtainMetadata();
+      return this._metadata(...keys);
+    }
+  }
+  /** User ID */
+  get userid() {
+    return Number(this._metadata("id"));
+  }
+  /** Profile Name (lowercase) */
+  get username() {
+    return this._metadata("username").toLowerCase();
+  }
+  toString() {
+    try {
+      return `<Profile ${this.username} (${this.userid})>`;
+    } catch {
+      return `<Profile ${this.username}>`;
+    }
+  }
+  equals(other) {
+    try {
+      return this.userid === other.userid;
+    } catch {
+      return this.username === other.username;
+    }
+  }
+  /** Whether this is a private profile */
+  get is_private() {
+    return this._metadata("is_private");
+  }
+  /** Whether the viewer follows this profile */
+  get followed_by_viewer() {
+    try {
+      return this._metadata("followed_by_viewer");
+    } catch {
+      return false;
+    }
+  }
+  /** Number of posts */
+  async getMediacount() {
+    return await this.getMetadata("edge_owner_to_timeline_media", "count");
+  }
+  /** Number of followers */
+  async getFollowers() {
+    return await this.getMetadata("edge_followed_by", "count");
+  }
+  /** Number of followees */
+  async getFollowees() {
+    return await this.getMetadata("edge_follow", "count");
+  }
+  /** External URL in bio */
+  async getExternalUrl() {
+    try {
+      return await this.getMetadata("external_url");
+    } catch {
+      return null;
+    }
+  }
+  /** Whether this is a business account */
+  async getIsBusinessAccount() {
+    try {
+      return await this.getMetadata("is_business_account");
+    } catch {
+      return false;
+    }
+  }
+  /** Business category name */
+  async getBusinessCategoryName() {
+    try {
+      return await this.getMetadata("business_category_name");
+    } catch {
+      return null;
+    }
+  }
+  /** Biography (normalized) */
+  async getBiography() {
+    const bio = await this.getMetadata("biography");
+    return bio.normalize("NFC");
+  }
+  /** Full name */
+  async getFullName() {
+    return await this.getMetadata("full_name");
+  }
+  /** Whether the viewer blocked this profile */
+  get blocked_by_viewer() {
+    try {
+      return this._metadata("blocked_by_viewer");
+    } catch {
+      return false;
+    }
+  }
+  /** Whether this profile follows the viewer */
+  get follows_viewer() {
+    try {
+      return this._metadata("follows_viewer");
+    } catch {
+      return false;
+    }
+  }
+  /** Whether this profile has blocked the viewer */
+  get has_blocked_viewer() {
+    try {
+      return this._metadata("has_blocked_viewer");
+    } catch {
+      return false;
+    }
+  }
+  /** Whether this profile is verified */
+  async getIsVerified() {
+    try {
+      return await this.getMetadata("is_verified");
+    } catch {
+      return false;
+    }
+  }
+  /** Profile picture URL */
+  async getProfilePicUrl() {
+    if (this._context.iphoneSupport && this._context.is_logged_in) {
+      try {
+        if (!this._iphone_struct_) {
+          const data = await this._context.get_iphone_json(
+            `api/v1/users/${this.userid}/info/`,
+            {}
+          );
+          this._iphone_struct_ = data["user"];
+        }
+        const hdInfo = this._iphone_struct_["hd_profile_pic_url_info"];
+        return hdInfo["url"];
+      } catch (err) {
+        this._context.error(`Unable to fetch high quality profile pic: ${err}`);
+        return await this.getMetadata("profile_pic_url_hd");
+      }
+    }
+    return await this.getMetadata("profile_pic_url_hd");
+  }
+  /**
+   * Helper to check if a post is newer than the current first post.
+   * Used for determining the "first" (newest) post in an iteration.
+   */
+  static _makeIsNewestChecker() {
+    return (item, currentFirst) => {
+      if (currentFirst === null) {
+        return true;
+      }
+      return item.date.getTime() > currentFirst.date.getTime();
+    };
+  }
+  /**
+   * Retrieve all posts from a profile.
+   *
+   * @returns NodeIterator[Post]
+   */
+  getPosts() {
+    const loggedIn = this._context.is_logged_in;
+    let firstData;
+    if (!loggedIn) {
+      try {
+        const edgeData = this._metadata("edge_owner_to_timeline_media");
+        const countValue = edgeData["count"];
+        const baseData = {
+          edges: (edgeData["edges"] || []).map((e) => ({ node: e["node"] || e })),
+          page_info: edgeData["page_info"] || { has_next_page: false, end_cursor: null }
+        };
+        firstData = typeof countValue === "number" ? { ...baseData, count: countValue } : baseData;
+      } catch {
+      }
+    }
+    const baseOptions = {
+      context: this._context,
+      queryHash: null,
+      edgeExtractor: loggedIn ? (d) => d["data"]["xdt_api__v1__feed__user_timeline_graphql_connection"] : (d) => d["data"]["user"]["edge_owner_to_timeline_media"],
+      nodeWrapper: loggedIn ? (n) => Post.fromIphoneStruct(this._context, n) : (n) => new Post(this._context, n, this),
+      queryVariables: {
+        data: {
+          count: 12,
+          include_relationship_info: true,
+          latest_besties_reel_media: true,
+          latest_reel_media: true
+        },
+        ...loggedIn ? { username: this.username } : { id: this.userid }
+      },
+      queryReferer: `https://www.instagram.com/${this.username}/`,
+      isFirst: _Profile._makeIsNewestChecker(),
+      docId: loggedIn ? "7898261790222653" : "7950326061742207"
+    };
+    if (firstData !== void 0) {
+      return new NodeIterator({ ...baseOptions, firstData });
+    }
+    return new NodeIterator(baseOptions);
+  }
+  /**
+   * Get Posts that are marked as saved by the user.
+   *
+   * @returns NodeIterator[Post]
+   * @throws LoginRequiredException if not logged in as the target profile
+   */
+  getSavedPosts() {
+    if (this.username !== this._context.username) {
+      throw new LoginRequiredException(
+        `Login as ${this.username} required to get that profile's saved posts.`
+      );
+    }
+    return new NodeIterator({
+      context: this._context,
+      queryHash: "f883d95537fbcd400f466f63d42bd8a1",
+      edgeExtractor: (d) => d["data"]["user"]["edge_saved_media"],
+      nodeWrapper: (n) => new Post(this._context, n),
+      queryVariables: { id: this.userid },
+      queryReferer: `https://www.instagram.com/${this.username}/`
+    });
+  }
+  /**
+   * Retrieve all posts where a profile is tagged.
+   *
+   * @returns NodeIterator[Post]
+   */
+  getTaggedPosts() {
+    return new NodeIterator({
+      context: this._context,
+      queryHash: "e31a871f7301132ceaab56507a66bbb7",
+      edgeExtractor: (d) => d["data"]["user"]["edge_user_to_photos_of_you"],
+      nodeWrapper: (n) => {
+        const ownerId = Number(n["owner"]["id"]);
+        const ownerProfile = ownerId === this.userid ? this : void 0;
+        return new Post(this._context, n, ownerProfile);
+      },
+      queryVariables: { id: this.userid },
+      queryReferer: `https://www.instagram.com/${this.username}/`,
+      isFirst: _Profile._makeIsNewestChecker()
+    });
+  }
+  /** Returns Profile as a JSON-serializable object. */
+  toJSON() {
+    const jsonNode = { ...this._node };
+    delete jsonNode["edge_media_collections"];
+    delete jsonNode["edge_owner_to_timeline_media"];
+    delete jsonNode["edge_saved_media"];
+    delete jsonNode["edge_felix_video_timeline"];
+    if (this._iphone_struct_) {
+      jsonNode["iphone_struct"] = this._iphone_struct_;
+    }
+    return jsonNode;
+  }
+};
+var StoryItem = class _StoryItem {
+  _context;
+  _node;
+  _owner_profile;
+  _iphone_struct_ = null;
+  constructor(context, node, owner_profile = null) {
+    this._context = context;
+    this._node = node;
+    this._owner_profile = owner_profile;
+    if ("iphone_struct" in node) {
+      this._iphone_struct_ = node["iphone_struct"];
+    }
+  }
+  /**
+   * Create a StoryItem object from a given mediaid.
+   */
+  static async fromMediaid(context, mediaid) {
+    const picJson = await context.graphql_query(
+      "2b0673e0dc4580674a88d426fe00ea90",
+      { shortcode: mediaidToShortcode(mediaid) }
+    );
+    const shortcodeMedia = picJson["data"]["shortcode_media"];
+    if (shortcodeMedia === null) {
+      throw new BadResponseException("Fetching StoryItem metadata failed.");
+    }
+    return new _StoryItem(context, shortcodeMedia);
+  }
+  /** The mediaid is a decimal representation of the media shortcode. */
+  get mediaid() {
+    return BigInt(this._node["id"]);
+  }
+  /** Convert mediaid to a shortcode-like string. */
+  get shortcode() {
+    return mediaidToShortcode(this.mediaid);
+  }
+  toString() {
+    return `<StoryItem ${this.mediaid}>`;
+  }
+  equals(other) {
+    return this.mediaid === other.mediaid;
+  }
+  /** Profile instance of the story item's owner. */
+  async getOwnerProfile() {
+    if (!this._owner_profile) {
+      const owner = this._node["owner"];
+      this._owner_profile = await Profile.fromId(
+        this._context,
+        Number(owner["id"])
+      );
+    }
+    return this._owner_profile;
+  }
+  /** The StoryItem owner's lowercase name. */
+  async getOwnerUsername() {
+    return (await this.getOwnerProfile()).username;
+  }
+  /** The ID of the StoryItem owner. */
+  async getOwnerId() {
+    return (await this.getOwnerProfile()).userid;
+  }
+  /** Timestamp when the StoryItem was created (local time zone). */
+  get date_local() {
+    return new Date(this._node["taken_at_timestamp"] * 1e3);
+  }
+  /** Timestamp when the StoryItem was created (UTC). */
+  get date_utc() {
+    return new Date(this._node["taken_at_timestamp"] * 1e3);
+  }
+  /** Synonym to date_utc */
+  get date() {
+    return this.date_utc;
+  }
+  /** Timestamp when the StoryItem will get unavailable (local time zone). */
+  get expiring_local() {
+    return new Date(this._node["expiring_at_timestamp"] * 1e3);
+  }
+  /** Timestamp when the StoryItem will get unavailable (UTC). */
+  get expiring_utc() {
+    return new Date(this._node["expiring_at_timestamp"] * 1e3);
+  }
+  /** URL of the picture / video thumbnail of the StoryItem */
+  get url() {
+    const displayResources = this._node["display_resources"];
+    const lastResource = displayResources[displayResources.length - 1];
+    return lastResource["src"];
+  }
+  /** Type of story item: GraphStoryImage or GraphStoryVideo */
+  get typename() {
+    return this._node["__typename"];
+  }
+  /** Caption. */
+  get caption() {
+    const edgeMediaToCaption = this._node["edge_media_to_caption"];
+    if (edgeMediaToCaption) {
+      const edges = edgeMediaToCaption["edges"];
+      if (edges && edges.length > 0) {
+        const firstEdge = edges[0];
+        const node = firstEdge["node"];
+        return optionalNormalize(node["text"]);
+      }
+    }
+    if ("caption" in this._node) {
+      return optionalNormalize(this._node["caption"]);
+    }
+    return null;
+  }
+  /** List of all lowercased hashtags in the StoryItem's caption. */
+  get caption_hashtags() {
+    if (!this.caption) {
+      return [];
+    }
+    return extractHashtags(this.caption);
+  }
+  /** List of all lowercased profiles mentioned in the StoryItem's caption. */
+  get caption_mentions() {
+    if (!this.caption) {
+      return [];
+    }
+    return extractMentions(this.caption);
+  }
+  /** Printable caption. */
+  get pcaption() {
+    return this.caption ? ellipsifyCaption(this.caption) : "";
+  }
+  /** True if the StoryItem is a video. */
+  get is_video() {
+    return this._node["is_video"];
+  }
+  /** URL of the video, or null. */
+  get video_url() {
+    if (this.is_video) {
+      try {
+        const videoResources = this._node["video_resources"];
+        const lastResource = videoResources[videoResources.length - 1];
+        return lastResource["src"];
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  /** Returns StoryItem as a JSON-serializable object. */
+  toJSON() {
+    const node = { ...this._node };
+    if (this._owner_profile) {
+      node["owner"] = this._owner_profile.toJSON();
+    }
+    if (this._iphone_struct_) {
+      node["iphone_struct"] = this._iphone_struct_;
+    }
+    return node;
+  }
+};
+var Story = class {
+  _context;
+  _node;
+  _unique_id = null;
+  _owner_profile = null;
+  _iphone_struct_ = null;
+  constructor(context, node) {
+    this._context = context;
+    this._node = node;
+  }
+  toString() {
+    const date = this.latest_media_utc;
+    return `<Story by ${this.owner_username} changed ${date.toISOString()}>`;
+  }
+  equals(other) {
+    return this.unique_id === other.unique_id;
+  }
+  /**
+   * This ID only equals amongst Story instances which have the same owner
+   * and the same set of StoryItem.
+   */
+  get unique_id() {
+    if (!this._unique_id) {
+      const items = this._node["items"];
+      const idList = items.map((item) => BigInt(item["id"])).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+      this._unique_id = String(this.owner_id) + idList.map(String).join("");
+    }
+    return this._unique_id;
+  }
+  /** Timestamp of the most recent StoryItem that has been watched or null (local time zone). */
+  get last_seen_local() {
+    const seen = this._node["seen"];
+    if (seen) {
+      return new Date(seen * 1e3);
+    }
+    return null;
+  }
+  /** Timestamp of the most recent StoryItem that has been watched or null (UTC). */
+  get last_seen_utc() {
+    return this.last_seen_local;
+  }
+  /** Timestamp when the last item of the story was created (local time zone). */
+  get latest_media_local() {
+    return new Date(this._node["latest_reel_media"] * 1e3);
+  }
+  /** Timestamp when the last item of the story was created (UTC). */
+  get latest_media_utc() {
+    return new Date(this._node["latest_reel_media"] * 1e3);
+  }
+  /** Count of items associated with the Story instance. */
+  get itemcount() {
+    return this._node["items"].length;
+  }
+  /** Profile instance of the story owner. */
+  get owner_profile() {
+    if (!this._owner_profile) {
+      this._owner_profile = new Profile(
+        this._context,
+        this._node["user"]
+      );
+    }
+    return this._owner_profile;
+  }
+  /** The story owner's lowercase username. */
+  get owner_username() {
+    return this.owner_profile.username;
+  }
+  /** The story owner's ID. */
+  get owner_id() {
+    return this.owner_profile.userid;
+  }
+  async _fetchIphoneStruct() {
+    if (this._context.iphoneSupport && this._context.is_logged_in && !this._iphone_struct_) {
+      const data = await this._context.get_iphone_json(
+        `api/v1/feed/reels_media/?reel_ids=${this.owner_id}`,
+        {}
+      );
+      const reels = data["reels"];
+      this._iphone_struct_ = reels[String(this.owner_id)];
+    }
+  }
+  /** Retrieve all items from a story. */
+  async *getItems() {
+    await this._fetchIphoneStruct();
+    const items = [...this._node["items"]].reverse();
+    for (const item of items) {
+      const itemObj = { ...item };
+      if (this._iphone_struct_ !== null) {
+        const iphoneItems = this._iphone_struct_["items"];
+        for (const iphoneItem of iphoneItems) {
+          const iphoneObj = iphoneItem;
+          if (String(iphoneObj["pk"]) === String(itemObj["id"])) {
+            itemObj["iphone_struct"] = iphoneObj;
+            break;
+          }
+        }
+      }
+      yield new StoryItem(this._context, itemObj, this.owner_profile);
+    }
+  }
+};
+var Highlight = class extends Story {
+  _items = null;
+  constructor(context, node, owner = null) {
+    super(context, node);
+    this._owner_profile = owner;
+  }
+  toString() {
+    return `<Highlight by ${this.owner_username}: ${this.title}>`;
+  }
+  /** A unique ID identifying this set of highlights. */
+  get unique_id() {
+    return String(this._node["id"]);
+  }
+  /** Profile instance of the highlights' owner. */
+  get owner_profile() {
+    if (!this._owner_profile) {
+      this._owner_profile = new Profile(
+        this._context,
+        this._node["owner"]
+      );
+    }
+    return this._owner_profile;
+  }
+  /** The title of these highlights. */
+  get title() {
+    return this._node["title"];
+  }
+  /** URL of the highlights' cover. */
+  get cover_url() {
+    const coverMedia = this._node["cover_media"];
+    return coverMedia["thumbnail_src"];
+  }
+  /** URL of the cropped version of the cover. */
+  get cover_cropped_url() {
+    const coverMedia = this._node["cover_media_cropped_thumbnail"];
+    return coverMedia["url"];
+  }
+  async _fetchItems() {
+    if (!this._items) {
+      const data = await this._context.graphql_query(
+        "45246d3fe16ccc6577e0bd297a5db1ab",
+        {
+          reel_ids: [],
+          tag_names: [],
+          location_ids: [],
+          highlight_reel_ids: [String(this.unique_id)],
+          precomposed_overlay: false
+        }
+      );
+      const dataObj = data["data"];
+      const reelsMedia = dataObj["reels_media"];
+      const firstReel = reelsMedia[0];
+      this._items = firstReel["items"];
+    }
+  }
+  async _fetchIphoneStruct() {
+    if (this._context.iphoneSupport && this._context.is_logged_in && !this._iphone_struct_) {
+      const data = await this._context.get_iphone_json(
+        `api/v1/feed/reels_media/?reel_ids=highlight:${this.unique_id}`,
+        {}
+      );
+      const reels = data["reels"];
+      this._iphone_struct_ = reels[`highlight:${this.unique_id}`];
+    }
+  }
+  /** Count of items associated with the Highlight instance. */
+  get itemcount() {
+    if (this._items) {
+      return this._items.length;
+    }
+    const items = this._node["items"];
+    return items?.length ?? 0;
+  }
+  /** Get accurate item count (async). */
+  async getItemcount() {
+    await this._fetchItems();
+    return this._items.length;
+  }
+  /** Retrieve all associated highlight items. */
+  async *getItems() {
+    await this._fetchItems();
+    await this._fetchIphoneStruct();
+    for (const item of this._items) {
+      const itemObj = { ...item };
+      if (this._iphone_struct_ !== null) {
+        const iphoneItems = this._iphone_struct_["items"];
+        for (const iphoneItem of iphoneItems) {
+          const iphoneObj = iphoneItem;
+          if (String(iphoneObj["pk"]) === String(itemObj["id"])) {
+            itemObj["iphone_struct"] = iphoneObj;
+            break;
+          }
+        }
+      }
+      yield new StoryItem(this._context, itemObj, this.owner_profile);
+    }
+  }
+};
+var Hashtag = class _Hashtag {
+  _context;
+  _node;
+  _has_full_metadata = false;
+  constructor(context, node) {
+    if (!("name" in node)) {
+      throw new Error("Node must contain 'name'");
+    }
+    this._context = context;
+    this._node = node;
+  }
+  /**
+   * Create a Hashtag instance from a given hashtag name, without preceding '#'.
+   */
+  static async fromName(context, name) {
+    const hashtag = new _Hashtag(context, { name: name.toLowerCase() });
+    await hashtag._obtainMetadata();
+    return hashtag;
+  }
+  /** Hashtag name lowercased, without preceding '#' */
+  get name() {
+    return this._node["name"].toLowerCase();
+  }
+  async _query(params) {
+    const jsonResponse = await this._context.get_iphone_json(
+      "api/v1/tags/web_info/",
+      { ...params, tag_name: this.name }
+    );
+    if ("graphql" in jsonResponse) {
+      return jsonResponse["graphql"]["hashtag"];
+    }
+    return jsonResponse["data"];
+  }
+  async _obtainMetadata() {
+    if (!this._has_full_metadata) {
+      this._node = await this._query({ __a: 1, __d: "dis" });
+      this._has_full_metadata = true;
+    }
+  }
+  _metadata(...keys) {
+    let d = this._node;
+    for (const key of keys) {
+      if (typeof d !== "object" || d === null || Array.isArray(d)) {
+        throw new Error("Key not found");
+      }
+      d = d[key];
+      if (d === void 0) {
+        throw new Error("Key not found");
+      }
+    }
+    return d;
+  }
+  async getMetadata(...keys) {
+    try {
+      return this._metadata(...keys);
+    } catch {
+      await this._obtainMetadata();
+      return this._metadata(...keys);
+    }
+  }
+  toString() {
+    return `<Hashtag #${this.name}>`;
+  }
+  equals(other) {
+    return this.name === other.name;
+  }
+  /** Hashtag ID */
+  async getHashtagId() {
+    return Number(await this.getMetadata("id"));
+  }
+  /** Profile picture URL of the hashtag */
+  async getProfilePicUrl() {
+    return await this.getMetadata("profile_pic_url");
+  }
+  /** Hashtag description */
+  async getDescription() {
+    try {
+      return await this.getMetadata("description");
+    } catch {
+      return null;
+    }
+  }
+  /** Whether following is allowed */
+  async getAllowFollowing() {
+    return Boolean(await this.getMetadata("allow_following"));
+  }
+  /** Whether the current user is following this hashtag */
+  async getIsFollowing() {
+    try {
+      return await this.getMetadata("is_following");
+    } catch {
+      return Boolean(await this.getMetadata("following"));
+    }
+  }
+  /** Count of all media associated with this hashtag */
+  async getMediacount() {
+    try {
+      return await this.getMetadata("edge_hashtag_to_media", "count");
+    } catch {
+      return await this.getMetadata("media_count");
+    }
+  }
+  /** Yields the top posts of the hashtag. */
+  async *getTopPosts() {
+    try {
+      const edges = await this.getMetadata(
+        "edge_hashtag_to_top_posts",
+        "edges"
+      );
+      for (const edge of edges) {
+        const e = edge;
+        yield new Post(this._context, e["node"]);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Yields the recent posts associated with this hashtag.
+   *
+   * @deprecated Use getPostsResumable() as this method may return incorrect results.
+   */
+  async *getPosts() {
+    try {
+      let conn = await this.getMetadata("edge_hashtag_to_media");
+      const edges = conn["edges"];
+      for (const edge of edges) {
+        yield new Post(this._context, edge["node"]);
+      }
+      let pageInfo = conn["page_info"];
+      while (pageInfo["has_next_page"]) {
+        const data = await this._query({
+          __a: 1,
+          max_id: pageInfo["end_cursor"]
+        });
+        conn = data["edge_hashtag_to_media"];
+        const newEdges = conn["edges"];
+        for (const edge of newEdges) {
+          yield new Post(this._context, edge["node"]);
+        }
+        pageInfo = conn["page_info"];
+      }
+    } catch {
+    }
+  }
+  /**
+   * Get the recent posts of the hashtag in a resumable fashion.
+   *
+   * @returns NodeIterator[Post]
+   */
+  getPostsResumable() {
+    return new NodeIterator({
+      context: this._context,
+      queryHash: "9b498c08113f1e09617a1703c22b2f32",
+      edgeExtractor: (d) => d["data"]["hashtag"]["edge_hashtag_to_media"],
+      nodeWrapper: (n) => new Post(this._context, n),
+      queryVariables: { tag_name: this.name },
+      queryReferer: `https://www.instagram.com/explore/tags/${this.name}/`
+    });
+  }
+  /** Returns Hashtag as a JSON-serializable object. */
+  toJSON() {
+    const jsonNode = { ...this._node };
+    delete jsonNode["edge_hashtag_to_top_posts"];
+    delete jsonNode["top"];
+    delete jsonNode["edge_hashtag_to_media"];
+    delete jsonNode["recent"];
+    return jsonNode;
+  }
+};
+var TopSearchResults = class {
+  _context;
+  _searchstring;
+  _node = null;
+  constructor(context, searchstring) {
+    this._context = context;
+    this._searchstring = searchstring;
+  }
+  async _ensureLoaded() {
+    if (!this._node) {
+      this._node = await this._context.getJson("web/search/topsearch/", {
+        context: "blended",
+        query: this._searchstring,
+        include_reel: false,
+        __a: 1
+      });
+    }
+    return this._node;
+  }
+  /** Provides the Profile instances from the search result. */
+  async *getProfiles() {
+    const node = await this._ensureLoaded();
+    const users = node["users"] ?? [];
+    for (const user of users) {
+      const userObj = user;
+      const userNode = userObj["user"];
+      if ("pk" in userNode) {
+        userNode["id"] = userNode["pk"];
+      }
+      yield new Profile(this._context, userNode);
+    }
+  }
+  /** Provides all profile names from the search result that start with the search string. */
+  async *getPrefixedUsernames() {
+    const node = await this._ensureLoaded();
+    const users = node["users"] ?? [];
+    for (const user of users) {
+      const userObj = user;
+      const innerUser = userObj["user"];
+      const username = innerUser["username"] ?? "";
+      if (username.startsWith(this._searchstring)) {
+        yield username;
+      }
+    }
+  }
+  /** Provides instances of PostLocation from the search result. */
+  async *getLocations() {
+    const node = await this._ensureLoaded();
+    const places = node["places"] ?? [];
+    for (const location of places) {
+      const locationObj = location;
+      const place = locationObj["place"];
+      const slug = place["slug"];
+      const loc = place["location"];
+      yield {
+        id: Number(loc["pk"]),
+        name: loc["name"],
+        slug,
+        has_public_page: null,
+        lat: loc["lat"] ?? null,
+        lng: loc["lng"] ?? null
+      };
+    }
+  }
+  /** Provides the hashtags from the search result as strings. */
+  async *getHashtagStrings() {
+    const node = await this._ensureLoaded();
+    const hashtags = node["hashtags"] ?? [];
+    for (const hashtag of hashtags) {
+      const hashtagObj = hashtag;
+      const inner = hashtagObj["hashtag"];
+      const name = inner["name"];
+      if (name) {
+        yield name;
+      }
+    }
+  }
+  /** Provides the hashtags from the search result. */
+  async *getHashtags() {
+    const node = await this._ensureLoaded();
+    const hashtags = node["hashtags"] ?? [];
+    for (const hashtag of hashtags) {
+      const hashtagObj = hashtag;
+      const inner = hashtagObj["hashtag"];
+      if ("name" in inner) {
+        yield new Hashtag(this._context, inner);
+      }
+    }
+  }
+  /** The string that was searched for on Instagram. */
+  get searchstring() {
+    return this._searchstring;
+  }
+};
+function getJsonStructure(structure) {
+  return {
+    node: structure.toJSON(),
+    instaloader: {
+      version: "4.15.0",
+      // Match Python version
+      node_type: structure.constructor.name
+    }
+  };
+}
+function loadStructure(context, jsonStructure) {
+  if ("node" in jsonStructure && "instaloader" in jsonStructure) {
+    const instaloader = jsonStructure["instaloader"];
+    if ("node_type" in instaloader) {
+      const nodeType = instaloader["node_type"];
+      const node = jsonStructure["node"];
+      switch (nodeType) {
+        case "Post":
+          return new Post(context, node);
+        case "Profile":
+          return new Profile(context, node);
+        case "StoryItem":
+          return new StoryItem(context, node);
+        case "Hashtag":
+          return new Hashtag(context, node);
+      }
+    }
+  }
+  if ("shortcode" in jsonStructure) {
+    return new Post(context, jsonStructure);
+  }
+  throw new InvalidArgumentException(
+    "Passed json structure is not an Instaloader JSON"
+  );
+}
+
+// src/instaloader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function getConfigDir() {
+  if (process.platform === "win32") {
+    const localAppData = process.env["LOCALAPPDATA"];
+    if (localAppData) {
+      return path.join(localAppData, "Instaloader");
+    }
+    return path.join(os.tmpdir(), `.instaloader-${os.userInfo().username}`);
+  }
+  const xdgConfig = process.env["XDG_CONFIG_HOME"] || path.join(os.homedir(), ".config");
+  return path.join(xdgConfig, "instaloader");
+}
+function getDefaultSessionFilename(username) {
+  return path.join(getConfigDir(), `session-${username}`);
+}
+function getDefaultStampsFilename() {
+  return path.join(getConfigDir(), "latest-stamps.ini");
+}
+function formatStringContainsKey(formatString, key) {
+  const pattern = new RegExp(`\\{${key}(?:\\.[^:}]*)?(?::[^}]*)?\\}`, "g");
+  return pattern.test(formatString);
+}
+function sanitizePath(str, forceWindowsPath = false) {
+  let result = str.replace(/\//g, "\u2215");
+  if (result.startsWith(".")) {
+    result = "\u2024" + result.slice(1);
+  }
+  if (forceWindowsPath || process.platform === "win32") {
+    result = result.replace(/:/g, "\uFF1A").replace(/</g, "\uFE64").replace(/>/g, "\uFE65").replace(/"/g, "\uFF02").replace(/\\/g, "\uFE68").replace(/\|/g, "\uFF5C").replace(/\?/g, "\uFE16").replace(/\*/g, "\uFF0A").replace(/\n/g, " ").replace(/\r/g, " ");
+    const reserved = /* @__PURE__ */ new Set([
+      "CON",
+      "PRN",
+      "AUX",
+      "NUL",
+      "COM1",
+      "COM2",
+      "COM3",
+      "COM4",
+      "COM5",
+      "COM6",
+      "COM7",
+      "COM8",
+      "COM9",
+      "LPT1",
+      "LPT2",
+      "LPT3",
+      "LPT4",
+      "LPT5",
+      "LPT6",
+      "LPT7",
+      "LPT8",
+      "LPT9"
+    ]);
+    const ext = path.extname(result);
+    let root = result.slice(0, result.length - ext.length);
+    if (reserved.has(root.toUpperCase())) {
+      root += "_";
+    }
+    const finalExt = ext === "." ? "\u2024" : ext;
+    result = root + finalExt;
+  }
+  return result;
+}
+function formatFilename(pattern, item, target, sanitize = false) {
+  let result = pattern;
+  const replacements = {
+    target
+  };
+  if (item instanceof Profile) {
+    replacements["profile"] = item.username;
+  }
+  if (item instanceof Post) {
+    replacements["date_utc"] = formatDate(item.date_utc);
+    replacements["date_local"] = formatDate(item.date_local);
+    replacements["shortcode"] = item.shortcode;
+    replacements["mediaid"] = item.mediaid.toString();
+    replacements["typename"] = item.typename;
+  } else if (item instanceof StoryItem) {
+    replacements["date_utc"] = formatDate(item.date_utc);
+    replacements["date_local"] = formatDate(item.date_local);
+    replacements["mediaid"] = item.mediaid?.toString();
+    replacements["typename"] = item.typename;
+  }
+  for (const [key, value] of Object.entries(replacements)) {
+    if (value !== void 0) {
+      const placeholder = new RegExp(`\\{${key}(?::[^}]*)?\\}`, "g");
+      let replacement = value;
+      if (sanitize) {
+        replacement = sanitizePath(value);
+      }
+      result = result.replace(placeholder, replacement);
+    }
+  }
+  return result;
+}
+function formatDate(date) {
+  if (!date) return "";
+  return date.toISOString().replace(/[:.]/g, "-").slice(0, 19);
+}
+var Instaloader = class {
+  /** The associated InstaloaderContext for low-level operations */
+  context;
+  // Configuration
+  dirnamePattern;
+  filenamePattern;
+  titlePattern;
+  downloadPictures;
+  downloadVideos;
+  downloadVideoThumbnails;
+  downloadGeotags;
+  downloadComments;
+  saveMetadata;
+  compressJson;
+  postMetadataTxtPattern;
+  storyitemMetadataTxtPattern;
+  resumePrefix;
+  checkResumeBbd;
+  sanitizePaths;
+  // Slide configuration
+  slide;
+  slideStart;
+  slideEnd;
+  constructor(options = {}) {
+    this.context = new InstaloaderContext({
+      ...options.sleep !== void 0 && { sleep: options.sleep },
+      ...options.quiet !== void 0 && { quiet: options.quiet },
+      ...options.userAgent !== void 0 && { userAgent: options.userAgent },
+      ...options.maxConnectionAttempts !== void 0 && { maxConnectionAttempts: options.maxConnectionAttempts },
+      ...options.requestTimeout !== void 0 && { requestTimeout: options.requestTimeout },
+      ...options.rateController !== void 0 && { rateController: options.rateController },
+      ...options.fatalStatusCodes !== void 0 && { fatalStatusCodes: options.fatalStatusCodes },
+      ...options.iphoneSupport !== void 0 && { iphoneSupport: options.iphoneSupport }
+    });
+    this.dirnamePattern = options.dirnamePattern ?? "{target}";
+    this.filenamePattern = options.filenamePattern ?? "{date_utc}_UTC";
+    if (options.titlePattern !== void 0) {
+      this.titlePattern = options.titlePattern;
+    } else if (formatStringContainsKey(this.dirnamePattern, "profile") || formatStringContainsKey(this.dirnamePattern, "target")) {
+      this.titlePattern = "{date_utc}_UTC_{typename}";
+    } else {
+      this.titlePattern = "{target}_{date_utc}_UTC_{typename}";
+    }
+    this.sanitizePaths = options.sanitizePaths ?? false;
+    this.downloadPictures = options.downloadPictures ?? true;
+    this.downloadVideos = options.downloadVideos ?? true;
+    this.downloadVideoThumbnails = options.downloadVideoThumbnails ?? true;
+    this.downloadGeotags = options.downloadGeotags ?? false;
+    this.downloadComments = options.downloadComments ?? false;
+    this.saveMetadata = options.saveMetadata ?? true;
+    this.compressJson = options.compressJson ?? true;
+    this.postMetadataTxtPattern = options.postMetadataTxtPattern ?? "{caption}";
+    this.storyitemMetadataTxtPattern = options.storyitemMetadataTxtPattern ?? "";
+    this.resumePrefix = options.resumePrefix === null ? null : options.resumePrefix ?? "iterator";
+    this.checkResumeBbd = options.checkResumeBbd ?? true;
+    this.slide = options.slide ?? "";
+    this.slideStart = 0;
+    this.slideEnd = -1;
+    if (this.slide !== "") {
+      const parts = this.slide.split("-");
+      if (parts.length === 1) {
+        if (parts[0] === "last") {
+          this.slideStart = -1;
+        } else {
+          const num = parseInt(parts[0], 10);
+          if (num > 0) {
+            this.slideStart = this.slideEnd = num - 1;
+          } else {
+            throw new InvalidArgumentException("--slide parameter must be greater than 0.");
+          }
+        }
+      } else if (parts.length === 2) {
+        if (parts[1] === "last") {
+          this.slideStart = parseInt(parts[0], 10) - 1;
+        } else {
+          const start = parseInt(parts[0], 10);
+          const end = parseInt(parts[1], 10);
+          if (start > 0 && start < end) {
+            this.slideStart = start - 1;
+            this.slideEnd = end - 1;
+          } else {
+            throw new InvalidArgumentException("Invalid data for --slide parameter.");
+          }
+        }
+      } else {
+        throw new InvalidArgumentException("Invalid data for --slide parameter.");
+      }
+    }
+  }
+  /**
+   * Close the session and clean up resources.
+   */
+  close() {
+    this.context.close();
+  }
+  // ================== Session Management ==================
+  /**
+   * Save session to a dictionary.
+   */
+  saveSession() {
+    if (!this.context.is_logged_in) {
+      throw new LoginRequiredException("Login required.");
+    }
+    return this.context.saveSession();
+  }
+  /**
+   * Load session from a dictionary.
+   */
+  loadSession(username, sessionData) {
+    this.context.loadSession(username, sessionData);
+  }
+  /**
+   * Save session to file.
+   */
+  async saveSessionToFile(filename) {
+    if (!this.context.is_logged_in) {
+      throw new LoginRequiredException("Login required.");
+    }
+    const targetFile = filename ?? getDefaultSessionFilename(this.context.username);
+    const dir = path.dirname(targetFile);
+    if (dir !== "" && !fs.existsSync(dir)) {
+      await fs.promises.mkdir(dir, { recursive: true, mode: 448 });
+    }
+    const sessionData = this.saveSession();
+    await fs.promises.writeFile(targetFile, JSON.stringify(sessionData), {
+      mode: 384
+    });
+    this.context.log(`Saved session to ${targetFile}.`);
+  }
+  /**
+   * Load session from file.
+   */
+  async loadSessionFromFile(username, filename) {
+    let targetFile = filename ?? getDefaultSessionFilename(username);
+    if (!fs.existsSync(targetFile)) {
+      throw new Error(`Session file not found: ${targetFile}`);
+    }
+    const content = await fs.promises.readFile(targetFile, "utf-8");
+    const sessionData = JSON.parse(content);
+    this.loadSession(username, sessionData);
+    this.context.log(`Loaded session from ${targetFile}.`);
+  }
+  /**
+   * Test if the current session is valid.
+   * Returns the username if logged in, null otherwise.
+   */
+  async testLogin() {
+    return this.context.testLogin();
+  }
+  /**
+   * Login with username and password.
+   */
+  async login(user, passwd) {
+    await this.context.login(user, passwd);
+  }
+  /**
+   * Complete two-factor authentication.
+   */
+  async twoFactorLogin(twoFactorCode) {
+    await this.context.twoFactorLogin(twoFactorCode);
+  }
+  // ================== Download Methods ==================
+  /**
+   * Download a picture or video from a URL.
+   *
+   * @param filename - Base filename (without extension)
+   * @param url - URL to download from
+   * @param mtime - Modification time to set on the file
+   * @param filenameSuffix - Optional suffix to add before extension
+   * @returns True if file was downloaded, false if it already existed
+   */
+  async downloadPic(filename, url, mtime, filenameSuffix) {
+    if (filenameSuffix) {
+      filename += "_" + filenameSuffix;
+    }
+    const urlMatch = url.match(/\.([a-z0-9]+)\?/i);
+    const fileExtension = urlMatch ? urlMatch[1] : url.slice(-3);
+    const nominalFilename = `${filename}.${fileExtension}`;
+    if (fs.existsSync(nominalFilename)) {
+      this.context.log(`${nominalFilename} exists`, false);
+      return false;
+    }
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": this.context.userAgent
+      }
+    });
+    if (!response.ok) {
+      throw new ConnectionException(`Failed to download: ${response.status} ${response.statusText}`);
+    }
+    let finalFilename = nominalFilename;
+    const contentType = response.headers.get("Content-Type");
+    if (contentType) {
+      let headerExtension = contentType.split(";")[0].split("/").pop().toLowerCase();
+      if (headerExtension === "jpeg") {
+        headerExtension = "jpg";
+      }
+      finalFilename = `${filename}.${headerExtension}`;
+    }
+    if (finalFilename !== nominalFilename && fs.existsSync(finalFilename)) {
+      this.context.log(`${finalFilename} exists`, false);
+      return false;
+    }
+    const dir = path.dirname(finalFilename);
+    if (dir && !fs.existsSync(dir)) {
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    await fs.promises.writeFile(finalFilename, buffer);
+    await fs.promises.utimes(finalFilename, /* @__PURE__ */ new Date(), mtime);
+    return true;
+  }
+  /**
+   * Save metadata JSON for a structure.
+   */
+  async saveMetadataJson(filename, structure) {
+    const jsonFilename = this.compressJson ? `${filename}.json.xz` : `${filename}.json`;
+    const dir = path.dirname(jsonFilename);
+    if (dir && !fs.existsSync(dir)) {
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+    const data = getJsonStructure(structure);
+    const json = JSON.stringify(data, null, 2);
+    if (this.compressJson) {
+      await fs.promises.writeFile(jsonFilename.replace(".xz", ""), json);
+    } else {
+      await fs.promises.writeFile(jsonFilename, json);
+    }
+    if (structure instanceof Post || structure instanceof StoryItem) {
+      this.context.log("json", false);
+    }
+  }
+  /**
+   * Save caption to a text file.
+   */
+  async saveCaption(filename, mtime, caption) {
+    const txtFilename = `${filename}.txt`;
+    const content = caption + "\n";
+    if (fs.existsSync(txtFilename)) {
+      const existing = await fs.promises.readFile(txtFilename, "utf-8");
+      if (existing.replace(/\r\n/g, "\n") === content.replace(/\r\n/g, "\n")) {
+        this.context.log("txt unchanged", false);
+        return;
+      }
+      this.context.log("txt updated", false);
+    } else {
+      const preview = caption.replace(/\n/g, " ").trim();
+      const ellipsified = preview.length > 31 ? `[${preview.slice(0, 29)}\u2026]` : `[${preview}]`;
+      this.context.log(ellipsified, false);
+    }
+    const dir = path.dirname(txtFilename);
+    if (dir && !fs.existsSync(dir)) {
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+    await fs.promises.writeFile(txtFilename, content, "utf-8");
+    await fs.promises.utimes(txtFilename, /* @__PURE__ */ new Date(), mtime);
+  }
+  /**
+   * Download a single post.
+   *
+   * @param post - Post to download
+   * @param target - Target directory name
+   * @returns True if something was downloaded
+   */
+  async downloadPost(post, target) {
+    const dirname2 = formatFilename(this.dirnamePattern, post, target, this.sanitizePaths);
+    const filename = path.join(
+      dirname2,
+      formatFilename(this.filenamePattern, post, target, this.sanitizePaths)
+    );
+    let downloaded = false;
+    if (this.downloadPictures) {
+      if (post.typename === "GraphSidecar") {
+        const sidecarNodes = post.getSidecarNodes();
+        let index = 0;
+        for await (const node of sidecarNodes) {
+          if (this.slideStart >= 0) {
+            if (index < this.slideStart) {
+              index++;
+              continue;
+            }
+            if (this.slideEnd >= 0 && index > this.slideEnd) {
+              break;
+            }
+          }
+          if (node.is_video) {
+            if (this.downloadVideos && node.video_url) {
+              const dl = await this.downloadPic(filename, node.video_url, post.date_utc, `${index + 1}`);
+              downloaded = downloaded || dl;
+            }
+          } else if (node.display_url) {
+            const dl = await this.downloadPic(filename, node.display_url, post.date_utc, `${index + 1}`);
+            downloaded = downloaded || dl;
+          }
+          index++;
+        }
+      } else if (post.is_video) {
+        if (this.downloadVideos) {
+          const videoUrl = post.video_url;
+          if (videoUrl) {
+            const dl = await this.downloadPic(filename, videoUrl, post.date_utc);
+            downloaded = downloaded || dl;
+          }
+        }
+        if (this.downloadVideoThumbnails && post.url) {
+          await this.downloadPic(filename, post.url, post.date_utc, "thumb");
+        }
+      } else {
+        if (post.url) {
+          const dl = await this.downloadPic(filename, post.url, post.date_utc);
+          downloaded = downloaded || dl;
+        }
+      }
+    }
+    if (this.saveMetadata) {
+      await this.saveMetadataJson(filename, post);
+    }
+    if (this.postMetadataTxtPattern && post.caption) {
+      await this.saveCaption(filename, post.date_utc, post.caption);
+    }
+    this.context.log("");
+    return downloaded;
+  }
+  /**
+   * Download posts from an iterator.
+   *
+   * @param posts - Iterator of posts
+   * @param target - Target directory name
+   * @param options - Download options
+   */
+  async downloadPosts(posts, target, options = {}) {
+    const {
+      fastUpdate = false,
+      postFilter,
+      maxCount,
+      totalCount,
+      // ownerProfile is reserved for future use (resume file naming)
+      possiblyPinned = 0
+    } = options;
+    const displayedCount = maxCount !== void 0 && (totalCount === void 0 || maxCount < totalCount) ? maxCount : totalCount;
+    let number = 0;
+    for await (const post of posts) {
+      number++;
+      if (maxCount !== void 0 && number > maxCount) {
+        break;
+      }
+      if (displayedCount !== void 0) {
+        const width = displayedCount.toString().length;
+        this.context.log(`[${number.toString().padStart(width)}/${displayedCount.toString().padStart(width)}] `, false);
+      } else {
+        this.context.log(`[${number.toString().padStart(3)}] `, false);
+      }
+      if (postFilter) {
+        try {
+          if (!postFilter(post)) {
+            this.context.log(`${post} skipped`);
+            continue;
+          }
+        } catch (err) {
+          this.context.error(`${post} skipped. Filter evaluation failed: ${err}`);
+          continue;
+        }
+      }
+      try {
+        const downloaded = await this.downloadPost(post, target);
+        if (fastUpdate && !downloaded && number > possiblyPinned) {
+          break;
+        }
+      } catch (err) {
+        if (err instanceof PostChangedException) {
+          continue;
+        }
+        this.context.error(`Download ${post} of ${target}: ${err}`);
+      }
+    }
+  }
+  /**
+   * Download a profile's posts.
+   */
+  async downloadProfile(profile, options = {}) {
+    const {
+      fastUpdate = false,
+      postFilter,
+      maxCount,
+      downloadProfilePic = true,
+      downloadStories = false,
+      downloadHighlights = false
+    } = options;
+    const target = profile.username.toLowerCase();
+    this.context.log(`Downloading profile ${target}...`);
+    if (downloadProfilePic) {
+      await this.downloadProfilePic(profile);
+    }
+    let count = 0;
+    const postIterator = profile.getPosts();
+    for await (const post of postIterator) {
+      if (maxCount !== void 0 && count >= maxCount) {
+        break;
+      }
+      if (postFilter && !postFilter(post)) {
+        continue;
+      }
+      if (fastUpdate) {
+        const dirname2 = formatFilename(this.dirnamePattern, post, target, this.sanitizePaths);
+        const postBasename = formatFilename(this.filenamePattern, post, target, this.sanitizePaths);
+        const metadataPath = path.join(dirname2, `${postBasename}.json`);
+        try {
+          await fs.promises.access(metadataPath);
+          this.context.log(`Fast update: Stopping at already downloaded post ${post.shortcode}`);
+          break;
+        } catch {
+        }
+      }
+      await this.downloadPost(post, target);
+      count++;
+    }
+    this.context.log(`Downloaded ${count} posts from ${target}`);
+    if (downloadStories && this.context.is_logged_in) {
+      this.context.log(`Downloading stories of ${target}...`);
+    }
+    if (downloadHighlights && this.context.is_logged_in) {
+      this.context.log(`Downloading highlights of ${target}...`);
+    }
+  }
+  /**
+   * Download a profile's profile picture.
+   */
+  async downloadProfilePic(profile) {
+    const url = await profile.getProfilePicUrl();
+    if (!url) return;
+    const dirname2 = formatFilename(this.dirnamePattern, profile, profile.username.toLowerCase(), this.sanitizePaths);
+    const filename = path.join(dirname2, `${profile.username.toLowerCase()}_profile_pic`);
+    await this.downloadPic(filename, url, /* @__PURE__ */ new Date());
+    this.context.log("");
+  }
+  /**
+   * Download posts for a hashtag.
+   */
+  async downloadHashtag(hashtag, options = {}) {
+    const { maxCount, postFilter, resumable = true } = options;
+    const target = `#${hashtag.name}`;
+    this.context.log(`Downloading hashtag ${target}...`);
+    let count = 0;
+    if (resumable) {
+      const postIterator = hashtag.getPostsResumable();
+      for await (const post of postIterator) {
+        if (maxCount !== void 0 && count >= maxCount) {
+          break;
+        }
+        if (postFilter && !postFilter(post)) {
+          continue;
+        }
+        await this.downloadPost(post, hashtag.name);
+        count++;
+      }
+    } else {
+      for await (const post of hashtag.getPosts()) {
+        if (maxCount !== void 0 && count >= maxCount) {
+          break;
+        }
+        if (postFilter && !postFilter(post)) {
+          continue;
+        }
+        await this.downloadPost(post, hashtag.name);
+        count++;
+      }
+    }
+    this.context.log(`Downloaded ${count} posts from ${target}`);
+  }
+  /**
+   * Get a profile by username.
+   */
+  async getProfile(username) {
+    return Profile.fromUsername(this.context, username);
+  }
+  /**
+   * Get a post by shortcode.
+   */
+  async getPost(shortcode) {
+    return Post.fromShortcode(this.context, shortcode);
+  }
+  /**
+   * Get a hashtag by name.
+   */
+  async getHashtag(name) {
+    return Hashtag.fromName(this.context, name);
+  }
+};
+export {
+  AbortDownloadException,
+  BadCredentialsException,
+  BadResponseException,
+  CheckpointRequiredException,
+  ConnectionException,
+  FrozenNodeIterator,
+  Hashtag,
+  Highlight,
+  IPhoneSupportDisabledException,
+  Instaloader,
+  InstaloaderContext,
+  InstaloaderException,
+  InvalidArgumentException,
+  InvalidIteratorException,
+  LoginException,
+  LoginRequiredException,
+  NodeIterator,
+  Post,
+  PostChangedException,
+  PostComment,
+  PrivateProfileNotFollowedException,
+  Profile,
+  ProfileHasNoPicsException,
+  ProfileNotExistsException,
+  QueryReturnedBadRequestException,
+  QueryReturnedForbiddenException,
+  QueryReturnedNotFoundException,
+  RateController,
+  SessionNotFoundException,
+  Story,
+  StoryItem,
+  TooManyRequestsException,
+  TopSearchResults,
+  TwoFactorAuthRequiredException,
+  defaultIphoneHeaders,
+  defaultUserAgent,
+  extractHashtags,
+  extractMentions,
+  formatFilename,
+  formatStringContainsKey,
+  getConfigDir,
+  getDefaultSessionFilename,
+  getDefaultStampsFilename,
+  getJsonStructure,
+  loadStructure,
+  mediaidToShortcode,
+  resumableIteration,
+  sanitizePath,
+  shortcodeToMediaid
+};